basemulticoder/basemulticoder.py at main · jabb4/basemulticoder · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
import base64
import argparse
import random

## Decode base16
def decode16(message):
    try:
        decoded_message = base64.b16decode(message)
        return decoded_message
    except:
        return False

## Decode base32
def decode32(message):
    try:
        decoded_message = base64.b32decode(message)
        return decoded_message
    except:
        return False

## Decode base64
def decode64(message):
    try:
        decoded_message = base64.b64decode(message)
        return decoded_message
    except:
        return False

## Encode base16
def encode16(message):
    encoded_message = base64.b16encode(message)
    return encoded_message

## Encode base32
def encode32(message):
    encoded_message = base64.b32encode(message)
    return encoded_message

## Encode base64
def encode64(message):
    encoded_message = base64.b64encode(message)
    return encoded_message

## Encode random
def random_encoding(message):
    choises_list = ["encode16", "encode32", "encode64"]
    choises_dict = {"encode16": encode16(message), "encode32": encode32(message), "encode64": encode64(message)}
    return choises_dict[random.choice(choises_list)]

## Try decoding with all
def decode(message):
    decoded_message = message
    while True:
        last = decoded_message
        decoded_message = decode16(last)

        if decoded_message:
            continue
        else:
            decoded_message = decode32(last)

        if decoded_message:
            continue
        else:
            decoded_message = decode64(last)

        if decoded_message:
            try:
                decoded_message.decode("utf-8")
                continue
            except:
                decoded_message = last
                break
        else:
            decoded_message = last
            break

    return decoded_message

def encode(message, base, turns):

    if base == "16":
        for x in range(turns):
            message = encode16(message)

    elif base == "32":
        for x in range(turns):
            message = encode32(message)

    elif base == "64":
        for x in range(turns):
            message = encode64(message)

    elif base == "rand":
        for x in range(turns):
            message = random_encoding(message)

    return(message.decode("utf-8"))

def main(args):
    ## Input
    if args.input or args.string:
        if args.input:
            with open(args.input) as input_file:
                input = input_file.read()
        else:
            input = args.string
    else:
        print("Error: Need an input, use -fi or -ti. Use -h for more help.")
        return(None)

    ## Mode
    ## Decode
    if args.mode.lower() == "decode":
        output = decode(input)
        try:
            print(output.decode("utf-8"))
        except AttributeError:
            print("Input could not be decoded! Try changing mode!")
            return(None)
    ## Encode
    elif args.mode and args.turns:
        if args.mode.lower() == "encode16":
            output = encode(input.encode(), "16", args.turns)
        elif args.mode.lower() == "encode32":
            output = encode(input.encode(), "32", args.turns)
        elif args.mode.lower() == "encode64":
            output = encode(input.encode(), "64", args.turns)
        elif args.mode.lower() == "encoderand":
            output = encode(input.encode(), "rand", args.turns)
        else:
            print("Error: Need an mode (-m Decode/Encode) and turns (-t) for encodes. Use -h for more help.")
            return(None)
        if not args.output:
            print(output)
    else:
        print("Error: Need an mode (-m Decode/Encode) and turns (-t) for encodes. Use -h for more help.")
        return(None)


    ## Output
    if args.output:
        with open(args.output, "w") as output_file:
            output_file.write(output)
        print ("Output has been saved!")
        return(None)


if __name__ == "__main__":
    ## Arguments setup
    parser = argparse.ArgumentParser()
    parser.add_argument("-fi", "--file", dest = "input", help="Input File")
    parser.add_argument("-si", "--string", dest = "string", help="Input String")
    parser.add_argument("-o", "--output", dest = "output", help="Output File")
    parser.add_argument("-m", "--mode",dest = "mode", help="Mode (Decode/Encode16/Encode32/Encode64/EncodeRAND)")
    parser.add_argument("-t", "--turns", dest = "turns", help="Encoding Turns", type=int)
    args = parser.parse_args()

    ## Run main function
    main(args)