data, config_file, section_name, option_name, value

):

global fish_keys

option = weechat.config_new_option(

config_file,

section_name,

option_name,

"string",

"key",

"",

0,

0,

"",

value,

0,

"",

"",

"",

"",

"",

"",

)

if not option:

return weechat.WEECHAT_CONFIG_OPTION_SET_ERROR

fish_keys[option_name] = value

global fish_keys, fish_secure_cipher

weechat.config_write_line(config_file, section_name, "")

for target, key in sorted(fish_keys.items()):

if fish_secure_cipher != None:

### ENCRYPT Targets/Keys ###

weechat.config_write_line(

config_file,

blowcrypt_pack(target, fish_secure_cipher),

blowcrypt_pack(key, fish_secure_cipher),

)

else:

weechat.config_write_line(config_file, target, key)

global fish_config_file, fish_config_section, fish_config_option

global fish_secure_cipher

fish_config_file = weechat.config_new(

CONFIG_FILE_NAME, "fish_config_reload_cb", ""

)

if not fish_config_file:

return

# look

fish_config_section["look"] = weechat.config_new_section(

fish_config_file, "look", 0, 0, "", "", "", "", "", "", "", "", "", ""

)

if not fish_config_section["look"]:

weechat.config_free(fish_config_file)

return

fish_config_option["announce"] = weechat.config_new_option(

fish_config_file,

fish_config_section["look"],

"announce",

"boolean",

"annouce if messages are being encrypted or not",

"",

0,

0,

"on",

"on",

0,

"",

"",

"",

"",

"",

"",

)

fish_config_option["marker"] = weechat.config_new_option(

fish_config_file,

fish_config_section["look"],

"marker",

"string",

"marker for important FiSH messages",

"",

0,

0,

"O<",

"O<",

0,

"",

"",

"",

"",

"",

"",

)

fish_config_option["mark_position"] = weechat.config_new_option(

fish_config_file,

fish_config_section["look"],

"mark_position",

"integer",

"put marker for encrypted messages at start or end",

"off|begin|end",

0,

2,

"off",

"off",

0,

"",

"",

"",

"",

"",

"",

)

fish_config_option["mark_encrypted"] = weechat.config_new_option(

fish_config_file,

fish_config_section["look"],

"mark_encrypted",

"string",

"marker for encrypted messages",

"",

0,

0,

"*",

"*",

0,

"",

"",

"",

"",

"",

"",

)

# color

fish_config_section["color"] = weechat.config_new_section(

fish_config_file, "color", 0, 0, "", "", "", "", "", "", "", "", "", ""

)

if not fish_config_section["color"]:

weechat.config_free(fish_config_file)

return

fish_config_option["alert"] = weechat.config_new_option(

fish_config_file,

fish_config_section["color"],

"alert",

"color",

"color for important FiSH message markers",

"",

0,

0,

"lightblue",

"lightblue",

0,

"",

"",

"",

"",

"",

"",

)

# secure

fish_config_section["secure"] = weechat.config_new_section(

fish_config_file,

"secure",

0,

0,

"",

"",

"",

"",

"",

"",

"",

"",

"",

"",

)

if not fish_config_section["secure"]:

weechat.config_free(fish_config_file)

return

fish_config_option["key"] = weechat.config_new_option(

fish_config_file,

fish_config_section["secure"],

"key",

"string",

"key for securing blowfish keys",

"",

0,

0,

"",

"",

0,

"",

"",

"",

"",

"",

"",

)

# keys

fish_config_section["keys"] = weechat.config_new_section(

fish_config_file,

"keys",

0,

0,

"fish_config_keys_read_cb",

"",

"fish_config_keys_write_cb",

"",

"",

"",

"",

"",

"",

"",

)

if not fish_config_section["keys"]:

weechat.config_free(fish_config_file)

def __init__(self, key=None):

if key:

if len(key) > 72:

key = key[:72]

self.blowfish = Crypto.Cipher.Blowfish.new(

key.encode('utf-8'), Crypto.Cipher.Blowfish.MODE_ECB

)

def decrypt(self, data):

return self.blowfish.decrypt(data)

def encrypt(self, data):

"""A non-standard base64-encode."""

B64 = "./0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

res = ""

while s:

left, right = struct.unpack(">LL", s[:8])

for i in range(6):

res += B64[right & 0x3F]

right >>= 6

for i in range(6):

res += B64[left & 0x3F]

left >>= 6

s = s[8:]

"""A non-standard base64-decode."""

B64 = "./0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

res = b""

while s:

left, right = 0, 0

for i, p in enumerate(s[0:6]):

right |= B64.index(p) << (i * 6)

for i, p in enumerate(s[6:12]):

left |= B64.index(p) << (i * 6)

res += bytes(

[

((left & (0xFF << ((3 - i) * 8))) >> ((3 - i) * 8))

for i in range(0, 4)

]

)

res += bytes(

[

((right & (0xFF << ((3 - i) * 8))) >> ((3 - i) * 8))

for i in range(0, 4)

]

)

s = s[12:]

"""Pads 'msg' with zeroes until it's length is divisible by 'length'.

L = len(msg)

if L % length:

msg += bytes(length - L % length)

assert len(msg) % length == 0

"""."""

if not (msg.startswith("+OK ") or msg.startswith("mcps ")):

raise ValueError

_, rest = msg.split(" ", 1)

if len(rest) < 12:

raise MalformedError

if not (len(rest) % 12) == 0:

rest = rest[: -(len(rest) % 12)]

try:

raw = blowcrypt_b64decode(padto(rest.encode('utf-8'), 12).decode('utf-8'))

except TypeError:

raise MalformedError

if not raw:

raise MalformedError

try:

plain = cipher.decrypt(raw)

except ValueError:

raise MalformedError

"FBE1022E23D213E8ACFA9AE8B9DFAD"

"A3EA6B7AC7A7B7E95AB5EB2DF85892"

"1FEADE95E6AC7BE7DE6ADBAB8A783E"

"7AF7A7FA6A2B7BEB1E72EAE2B72F9F"

"A2BFB2A2EFBEFAC868BADB3E828FA8"

"BADFADA3E4CC1BE7E8AFE85E9698A7"

"83EB68FA07A77AB6AD7BEB618ACF9C"

"A2897EB28A6189EFA07AB99A8A7FA9"

"AE299EFA7BA66DEAFEFBEFBF0B7D8B",

16,

"""A non-standard base64-encode."""

b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

d = [0] * len(s) * 2

L = len(s) * 8

m = 0x80

i, j, k, t = 0, 0, 0, 0

while i < L:

o = ord(s[i >> 3]) if isinstance(s, str) else s[i >> 3]

if o & m:

t |= 1

j += 1

m >>= 1

if not m:

m = 0x80

if not j % 6:

d[k] = b64[t]

t &= 0

k += 1

t <<= 1

t %= 0x100

#

i += 1

m = 5 - j % 6

t <<= m

t %= 0x100

if m:

d[k] = b64[t]

k += 1

d[k] = 0

res = ""

for q in d:

if q == 0:

break

res += q

"""A non-standard base64-encode."""

b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

buf = [0] * 256

for i in range(64):

buf[ord(b64[i])] = i

L = len(s)

if L < 2:

raise ValueError

for i in reversed(range(L - 1)):

if buf[ord(s[i])] == 0:

L -= 1

else:

break

if L < 2:

raise ValueError

d = [0] * L

i, k = 0, 0

while True:

i += 1

if k + 1 < L:

d[i - 1] = buf[ord(s[k])] << 2

d[i - 1] %= 0x100

else:

break

k += 1

if k < L:

d[i - 1] |= buf[ord(s[k])] >> 4

else:

break

i += 1

if k + 1 < L:

d[i - 1] = buf[ord(s[k])] << 4

d[i - 1] %= 0x100

else:

break

k += 1

if k < L:

d[i - 1] |= buf[ord(s[k])] >> 2

else:

break

i += 1

if k + 1 < L:

d[i - 1] = buf[ord(s[k])] << 6

d[i - 1] %= 0x100

else:

break

k += 1

if k < L:

d[i - 1] |= buf[ord(s[k])] % 0x100

else:

break

k += 1

"""DH1080 context."""

def __init__(self):

self.public = 0

self.private = 0

self.secret = 0

self.state = 0

bits = 1080

while True:

self.private = bytes2int(urandom(bits // 8))

self.public = pow(g_dh1080, self.private, p_dh1080)

if (

2 <= self.public <= p_dh1080 - 1

and dh_validate_public(self.public, q_dh1080, p_dh1080) == 1

):

"""."""

cmd = None

if ctx.state == 0:

ctx.state = 1

cmd = "DH1080_INIT "

else:

cmd = "DH1080_FINISH "

"""."""

if not msg.startswith("DH1080_"):

raise ValueError

invalidmsg = (

"Key does not validate per RFC 2631. This check is not "

"performed by any DH1080 implementation, so we use the key "

"anyway. See RFC 2785 for more details."

)

if ctx.state == 0:

if not msg.startswith("DH1080_INIT "):

raise MalformedError

ctx.state = 1

try:

cmd, public_raw = msg.split(" ", 1)

public = bytes2int(dh1080_b64decode(public_raw))

if not 1 < public < p_dh1080:

raise MalformedError

if not dh_validate_public(public, q_dh1080, p_dh1080):

# print(invalidmsg)

pass

ctx.secret = pow(public, ctx.private, p_dh1080)

except:

raise MalformedError

elif ctx.state == 1:

if not msg.startswith("DH1080_FINISH "):

raise MalformedError

ctx.state = 1

try:

cmd, public_raw = msg.split(" ", 1)

public = bytes2int(dh1080_b64decode(public_raw))

if not 1 < public < p_dh1080:

raise MalformedError

if not dh_validate_public(public, q_dh1080, p_dh1080):

# print(invalidmsg)

pass

ctx.secret = pow(public, ctx.private, p_dh1080)

except:

raise MalformedError

"""."""

if ctx.secret == 0:

raise ValueError

global fish_secure_key, fish_secure_cipher

fish_secure_key = weechat.config_string(

weechat.config_get("fish.secure.key")

)

if fish_secure_key == "":

fish_secure_cipher = None

return weechat.WEECHAT_RC_OK

if fish_secure_key[:6] == "${sec.":

decrypted = weechat.string_eval_expression(fish_secure_key, {}, {}, {})

if decrypted:

fish_secure_cipher = Blowfish(decrypted)

return weechat.WEECHAT_RC_OK

else:

weechat.config_option_set(fish_config_option["key"], "", 0)

weechat.prnt("", "Decrypt sec.conf first\n")

return weechat.WEECHAT_RC_OK

if fish_secure_key != "":

fish_secure_cipher = Blowfish(fish_secure_key)

global fish_DH1080ctx, fish_keys, fish_cyphers

match = re.match(

r"^(:(.*?)!.*? NOTICE (.*?) :)((DH1080_INIT |DH1080_FINISH |\+OK |mcps )?.*)$",

string,

)

# match.group(0): message

# match.group(1): msg without payload

# match.group(2): source

# match.group(3): target

# match.group(4): msg

# match.group(5): DH1080_INIT |DH1080_FINISH

if not match or not match.group(5):

return string

if match.group(3) != weechat.info_get("irc_nick", server_name):

return string

target = "%s/%s" % (server_name, match.group(2))

targetl = ("%s/%s" % (server_name, match.group(2))).lower()

buffer = weechat.info_get(

"irc_buffer", "%s,%s" % (server_name, match.group(2))

)

if match.group(5) == "DH1080_FINISH " and targetl in fish_DH1080ctx:

if not dh1080_unpack(match.group(4), fish_DH1080ctx[targetl]):

fish_announce_unencrypted(buffer, target)

return string

fish_alert(buffer, "Key exchange for %s sucessful" % target)

fish_keys[targetl] = dh1080_secret(fish_DH1080ctx[targetl])

if targetl in fish_cyphers:

del fish_cyphers[targetl]

del fish_DH1080ctx[targetl]

return ""

if match.group(5) == "DH1080_INIT ":

fish_DH1080ctx[targetl] = DH1080Ctx()

msg = " ".join(match.group(4).split()[0:2])

if not dh1080_unpack(msg, fish_DH1080ctx[targetl]):

fish_announce_unencrypted(buffer, target)

return string

reply = dh1080_pack(fish_DH1080ctx[targetl])

fish_alert(buffer, "Key exchange initiated by %s. Key set." % target)

weechat.command(

buffer, "/mute -all notice %s %s" % (match.group(2), reply)

)

fish_keys[targetl] = dh1080_secret(fish_DH1080ctx[targetl])

if targetl in fish_cyphers:

del fish_cyphers[targetl]

del fish_DH1080ctx[targetl]

return ""

if match.group(5) in ["+OK ", "mcps "]:

if targetl not in fish_keys:

fish_announce_unencrypted(buffer, target)

return string

if targetl not in fish_cyphers:

b = Blowfish(fish_keys[targetl])

fish_cyphers[targetl] = b

else:

b = fish_cyphers[targetl]

clean = blowcrypt_unpack(match.group(4), b)

fish_announce_encrypted(buffer, target)

return "%s%s" % (match.group(1), fish_msg_w_marker(clean))

fish_announce_unencrypted(buffer, target)

global fish_keys, fish_cyphers

match = re.match(

r"^(:(.*?)!.*? PRIVMSG (.*?) :)(\x01ACTION )?((\+OK |mcps )?.*?)(\x01)?$",

string,

)

# match.group(0): message

# match.group(1): msg without payload

# match.group(2): source

# match.group(3): target

# match.group(4): action

# match.group(5): msg

# match.group(6): +OK |mcps

if not match:

return string

if match.group(3) == weechat.info_get("irc_nick", server_name):

dest = match.group(2)

else:

dest = match.group(3)

target = "%s/%s" % (server_name, dest)

targetl = ("%s/%s" % (server_name, dest)).lower()

buffer = weechat.info_get("irc_buffer", "%s,%s" % (server_name, dest))

if not match.group(6):

fish_announce_unencrypted(buffer, target)

return string

if targetl not in fish_keys:

fish_announce_unencrypted(buffer, target)

return string

fish_announce_encrypted(buffer, target)

if targetl not in fish_cyphers:

b = Blowfish(fish_keys[targetl])

fish_cyphers[targetl] = b

else:

b = fish_cyphers[targetl]

clean = blowcrypt_unpack(match.group(5), b)

if not match.group(4):

return "%s%s" % (match.group(1), fish_msg_w_marker(clean))

return "%s%s%s\x01" % (

match.group(1),

match.group(4),

fish_msg_w_marker(clean),

global fish_keys, fish_cyphers

match = re.match(r"^(:.*?!.*? TOPIC (.*?) :)((\+OK |mcps )?.*)$", string)

# match.group(0): message

# match.group(1): msg without payload

# match.group(2): channel

# match.group(3): topic

# match.group(4): +OK |mcps

if not match:

return string

target = "%s/%s" % (server_name, match.group(2))

targetl = ("%s/%s" % (server_name, match.group(2))).lower()

buffer = weechat.info_get(

"irc_buffer", "%s,%s" % (server_name, match.group(2))

)

if targetl not in fish_keys or not match.group(4):

fish_announce_unencrypted(buffer, target)

return string

if targetl not in fish_cyphers:

b = Blowfish(fish_keys[targetl])

fish_cyphers[targetl] = b

else:

b = fish_cyphers[targetl]

clean = blowcrypt_unpack(match.group(3), b)

fish_announce_encrypted(buffer, target)

global fish_keys, fish_cyphers

match = re.match(r"^(:.*? 332 .*? (.*?) :)((\+OK |mcps )?.*)$", string)

if not match:

return string

target = "%s/%s" % (server_name, match.group(2))

targetl = ("%s/%s" % (server_name, match.group(2))).lower()

buffer = weechat.info_get(

"irc_buffer", "%s,%s" % (server_name, match.group(2))

)

if targetl not in fish_keys or not match.group(4):

fish_announce_unencrypted(buffer, target)

return string

if targetl not in fish_cyphers:

b = Blowfish(fish_keys[targetl])

fish_cyphers[targetl] = b

else:

b = fish_cyphers[targetl]

clean = blowcrypt_unpack(match.group(3), b)

fish_announce_encrypted(buffer, target)

global fish_keys, fish_cyphers

match = re.match(r"^(PRIVMSG (.*?) :)(.*)$", string)

if not match:

return string

target = "%s/%s" % (server_name, match.group(2))

targetl = ("%s/%s" % (server_name, match.group(2))).lower()

buffer = weechat.info_get(

"irc_buffer", "%s,%s" % (server_name, match.group(2))

)

if targetl not in fish_keys:

fish_announce_unencrypted(buffer, target)

return string

if targetl not in fish_cyphers:

b = Blowfish(fish_keys[targetl])

fish_cyphers[targetl] = b

else:

b = fish_cyphers[targetl]

cypher = blowcrypt_pack(fish_msg_wo_marker(match.group(3)), b)

fish_announce_encrypted(buffer, target)

global fish_keys, fish_cyphers

match = re.match(r"^(TOPIC (.*?) :)(.*)$", string)

if not match:

return string

if not match.group(3):

return string

target = "%s/%s" % (server_name, match.group(2))

targetl = ("%s/%s" % (server_name, match.group(2))).lower()

buffer = weechat.info_get(

"irc_buffer", "%s,%s" % (server_name, match.group(2))

)

if targetl not in fish_keys:

fish_announce_unencrypted(buffer, target)

return string

if targetl not in fish_cyphers:

b = Blowfish(fish_keys[targetl])

fish_cyphers[targetl] = b

else:

b = fish_cyphers[targetl]

cypher = blowcrypt_pack(match.group(3), b)

fish_announce_encrypted(buffer, target)