blob: fb20d1547e487671ab0480797667b81db5916ffc [file]
#**************************************************************
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
#
#**************************************************************
# usage: decrypt.py <in-dir> <out-dir> <password> (decrypt.py --selftest runs the cipher known-answer tests)
# Writes a plain copy of every package in <in-dir> into <out-dir> for the schema checkers: encrypted
# streams are decrypted and inflated, the manifest loses its encryption-data elements and the manifest:size
# of those entries. Do not run pkgcheck.py on the copies. A checksum mismatch (wrong password) or any other
# failure writes nothing for that package and makes the exit status 1.
# Implements what main/package writes and reads: PBKDF2-HMAC-SHA1 over the start key (SHA1 or SHA256 of the
# UTF-8 password), Blowfish with 64 bit feedback (rtl_cipher_CFB over 8 byte blocks) or AES-CBC with W3C padding.
import sys, os, io, re, zlib, zipfile, hashlib, base64, struct
from xml.etree import ElementTree as ET
M = "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"
Q = "{%s}" % M
ET.register_namespace("manifest", M)
MASK = 0xFFFFFFFF
class DecryptError(Exception):
pass
def pi_hex_words(n):
bits = 32 * n + 64
one = 1 << (bits + 16)
def arctan_inv(x):
x2, term, total, k = x * x, one // x, 0, 0
while term:
total += term // (2 * k + 1) if k % 2 == 0 else -(term // (2 * k + 1))
term //= x2
k += 1
return total
pi = 16 * arctan_inv(5) - 4 * arctan_inv(239)
frac = (pi - (3 * one)) >> 16
frac >>= 64
return [(frac >> (32 * (n - 1 - i))) & MASK for i in range(n)]
_BF_INIT = []
class Blowfish:
def __init__(self, key):
if not _BF_INIT:
_BF_INIT.extend(pi_hex_words(18 + 1024))
assert _BF_INIT[0] == 0x243F6A88 and _BF_INIT[18] == 0xD1310BA6 and _BF_INIT[-1] == 0x3AC372E6
self.P = _BF_INIT[:18]
self.S = [_BF_INIT[18 + 256 * i:18 + 256 * (i + 1)] for i in range(4)]
k = 0
for i in range(18):
d = 0
for _ in range(4):
d = (d << 8) | key[k]
k = (k + 1) % len(key)
self.P[i] ^= d
l = r = 0
for i in range(0, 18, 2):
l, r = self.encrypt(l, r)
self.P[i], self.P[i + 1] = l, r
for i in range(4):
for j in range(0, 256, 2):
l, r = self.encrypt(l, r)
self.S[i][j], self.S[i][j + 1] = l, r
def encrypt(self, l, r):
P, S0, S1, S2, S3 = self.P, *self.S
for i in range(16):
l ^= P[i]
r ^= ((((S0[l >> 24] + S1[(l >> 16) & 255]) & MASK) ^ S2[(l >> 8) & 255]) + S3[l & 255]) & MASK
l, r = r, l
l, r = r, l
return l ^ P[17], r ^ P[16]
def encrypt_block(self, b):
return struct.pack(">II", *self.encrypt(*struct.unpack(">II", b)))
def blowfish_cfb64_decrypt(key, iv, data):
bf = Blowfish(key)
reg = (iv + bytes(8))[:8]
out = bytearray()
for i in range(0, len(data), 8):
ct = data[i:i + 8]
ks = bf.encrypt_block(reg)
out += bytes(a ^ b for a, b in zip(ct, ks))
reg = ct
return bytes(out)
def _aes_tables():
def xt(a):
a <<= 1
return (a ^ 0x11B) & 255 if a & 256 else a
def mul(a, b):
r = 0
while b:
if b & 1:
r ^= a
a, b = xt(a), b >> 1
return r
inv = [0] * 256
for a in range(1, 256):
for b in range(1, 256):
if mul(a, b) == 1:
inv[a] = b
break
sbox = []
for a in range(256):
x = inv[a]
s = x ^ (x << 1 | x >> 7) & 255 ^ (x << 2 | x >> 6) & 255 ^ (x << 3 | x >> 5) & 255 ^ (x << 4 | x >> 4) & 255 ^ 0x63
sbox.append(s & 255)
isbox = [0] * 256
for i, s in enumerate(sbox):
isbox[s] = i
return sbox, isbox, {n: [mul(a, n) for a in range(256)] for n in (2, 9, 11, 13, 14)}
_AES = []
def aes_schedule(key):
if not _AES:
_AES.extend(_aes_tables())
sbox, mt = _AES[0], _AES[2]
if len(key) not in (16, 24, 32):
raise DecryptError("AES key size %d" % len(key))
nk = len(key) // 4
nr = nk + 6
w = [list(key[4 * i:4 * i + 4]) for i in range(nk)]
rcon = 1
for i in range(nk, 4 * (nr + 1)):
t = list(w[i - 1])
if i % nk == 0:
t = [sbox[b] for b in t[1:] + t[:1]]
t[0] ^= rcon
rcon = mt[2][rcon]
elif nk > 6 and i % nk == 4:
t = [sbox[b] for b in t]
w.append([a ^ b for a, b in zip(w[i - nk], t)])
return [sum(w[4 * r:4 * r + 4], []) for r in range(nr + 1)]
def aes_decrypt_block(rk, blk):
isbox, mt = _AES[1], _AES[2]
m9, m11, m13, m14 = mt[9], mt[11], mt[13], mt[14]
nr = len(rk) - 1
s = [a ^ b for a, b in zip(blk, rk[nr])]
for r in range(nr - 1, -1, -1):
s = [s[0], s[13], s[10], s[7], s[4], s[1], s[14], s[11], s[8], s[5], s[2], s[15], s[12], s[9], s[6], s[3]]
s = [isbox[b] ^ k for b, k in zip(s, rk[r])]
if r:
t = []
for c in range(0, 16, 4):
a0, a1, a2, a3 = s[c:c + 4]
t += [m14[a0] ^ m11[a1] ^ m13[a2] ^ m9[a3], m9[a0] ^ m14[a1] ^ m11[a2] ^ m13[a3],
m13[a0] ^ m9[a1] ^ m14[a2] ^ m11[a3], m11[a0] ^ m13[a1] ^ m9[a2] ^ m14[a3]]
s = t
return bytes(s)
def aes_cbc_decrypt(key, iv, data):
rk = aes_schedule(key)
if len(data) % 16 or not data:
raise DecryptError("AES data is not a multiple of 16 bytes")
out, prev = bytearray(), iv
for off in range(0, len(data), 16):
blk = data[off:off + 16]
out += bytes(a ^ b for a, b in zip(aes_decrypt_block(rk, blk), prev))
prev = blk
n = out[-1]
if not 1 <= n <= 16:
raise DecryptError("bad AES padding byte %d" % n)
return bytes(out[:-n])
def sha1_rtl(data):
"""SHA-1 as main/sal rtl_digest_SHA1 computes it: input lengths of 52..55 mod 64 get one extra padding block."""
h = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]
r = len(data) % 64
m = data + b"\x80" + bytes((55 - r) % 64) + (bytes(64) if 52 <= r <= 55 else b"") + struct.pack(">Q", len(data) * 8)
def rol(x, n):
return ((x << n) | (x >> (32 - n))) & MASK
for o in range(0, len(m), 64):
w = list(struct.unpack(">16I", m[o:o + 64]))
for i in range(16, 80):
w.append(rol(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1))
a, b, c, d, e = h
for i in range(80):
if i < 20:
f, k = (b & c) | (~b & d), 0x5A827999
elif i < 40:
f, k = b ^ c ^ d, 0x6ED9EBA1
elif i < 60:
f, k = (b & c) | (b & d) | (c & d), 0x8F1BBCDC
else:
f, k = b ^ c ^ d, 0xCA62C1D6
a, b, c, d, e = (rol(a, 5) + f + e + k + w[i]) & MASK, a, rol(b, 30), c, d
h = [(x + y) & MASK for x, y in zip(h, (a, b, c, d, e))]
return struct.pack(">5I", *h)
def b64(v, what):
try:
return base64.b64decode(v or "", validate=True)
except Exception:
raise DecryptError("%s is not base64: %r" % (what, v))
def entry_params(fe):
ed = fe.find(Q + "encryption-data")
alg, kd, sk = ed.find(Q + "algorithm"), ed.find(Q + "key-derivation"), ed.find(Q + "start-key-generation")
if alg is None or kd is None:
raise DecryptError("encryption-data lacks algorithm or key-derivation")
p = {"checksum": b64(ed.get(Q + "checksum"), "checksum") if ed.get(Q + "checksum") else None}
ctype = ed.get(Q + "checksum-type")
p["check"] = {"SHA1/1K": "sha1", M + "#sha1-1k": "sha1", M + "#sha256-1k": "sha256"}.get(ctype)
if p["check"] is None:
raise DecryptError("checksum-type %r" % ctype)
name = alg.get(Q + "algorithm-name")
keylen = {"http://www.w3.org/2001/04/xmlenc#aes128-cbc": 16, "http://www.w3.org/2001/04/xmlenc#aes192-cbc": 24,
"http://www.w3.org/2001/04/xmlenc#aes256-cbc": 32}.get(name)
if name in ("Blowfish CFB", M + "#blowfish"):
p["cipher"], keylen = "blowfish", 16
elif keylen:
p["cipher"] = "aes"
else:
raise DecryptError("algorithm-name %r" % name)
p["iv"] = b64(alg.get(Q + "initialisation-vector"), "initialisation-vector")
if kd.get(Q + "key-derivation-name") not in ("PBKDF2", M + "#pbkdf2"):
raise DecryptError("key-derivation-name %r" % kd.get(Q + "key-derivation-name"))
p["salt"] = b64(kd.get(Q + "salt"), "salt")
p["iter"] = int(kd.get(Q + "iteration-count"))
p["keylen"] = int(kd.get(Q + "key-size") or keylen)
sname = sk.get(Q + "start-key-generation-name") if sk is not None else "SHA1"
p["start"] = {"SHA1": "sha1", "http://www.w3.org/2000/09/xmldsig#sha1": "sha1",
"http://www.w3.org/2000/09/xmldsig#sha256": "sha256"}.get(sname)
if p["start"] is None:
raise DecryptError("start-key-generation-name %r" % sname)
return p
def raw_entry(path, zi):
with open(path, "rb") as f:
f.seek(zi.header_offset)
h = f.read(30)
if h[:4] != b"PK\x03\x04":
raise DecryptError("no local header for %s" % zi.filename)
n, e = struct.unpack("<HH", h[26:30])
f.seek(zi.header_offset + 30 + n + e)
return f.read(zi.compress_size)
def decrypt_entry(raw, p, password, name, notes):
start = hashlib.new(p["start"], password.encode("utf-8")).digest()
key = hashlib.pbkdf2_hmac("sha1", start, p["salt"], p["iter"], p["keylen"])
try:
plain = blowfish_cfb64_decrypt(key, p["iv"], raw) if p["cipher"] == "blowfish" else aes_cbc_decrypt(key, p["iv"], raw)
except DecryptError as e:
raise DecryptError("%s: %s (wrong password?)" % (name, e))
if p["checksum"] is not None and hashlib.new(p["check"], plain[:1024]).digest() != p["checksum"]:
if p["check"] == "sha1" and sha1_rtl(plain[:1024]) == p["checksum"]:
notes.append("%s: checksum is the non-standard SHA-1 of main/sal (hashed length %d, mod 64 = %d)"
% (name, len(plain[:1024]), len(plain[:1024]) % 64))
else:
raise DecryptError("%s: checksum mismatch (wrong password?)" % name)
try:
d = zlib.decompressobj(-15)
out = d.decompress(plain) + d.flush()
except zlib.error as e:
raise DecryptError("%s: decrypted data does not inflate (%s)" % (name, e))
if not d.eof:
raise DecryptError("%s: deflate stream is truncated" % name)
return out
def decrypt_package(src, dst, password, notes):
"""Returns the number of encrypted entries decrypted; 0 means the package was copied unchanged."""
z = zipfile.ZipFile(src)
mani = ET.fromstring(z.read("META-INF/manifest.xml"))
enc = {}
for fe in mani.findall(Q + "file-entry"):
if fe.find(Q + "encryption-data") is not None:
enc[fe.get(Q + "full-path")] = fe
data = {}
for zi in z.infolist():
n = zi.filename
if n in enc:
if zi.compress_type != zipfile.ZIP_STORED:
raise DecryptError("%s: encrypted entry is not STORED" % n)
plain = decrypt_entry(raw_entry(src, zi), entry_params(enc[n]), password, n, notes)
size = enc[n].get(Q + "size")
if size is not None and int(size) != len(plain):
raise DecryptError("%s: manifest:size %s, decrypted %d bytes" % (n, size, len(plain)))
data[n] = plain
else:
data[n] = z.read(n)
for fe in enc.values():
fe.remove(fe.find(Q + "encryption-data"))
fe.attrib.pop(Q + "size", None)
fe.text = None
missing = [p for p in enc if p not in data]
if missing:
raise DecryptError("manifest lists encrypted entries not in the zip: %s" % missing)
if enc:
data["META-INF/manifest.xml"] = ET.tostring(mani, encoding="UTF-8", xml_declaration=True)
tmp = dst + ".tmp"
with zipfile.ZipFile(tmp, "w") as o:
names = [zi.filename for zi in z.infolist()]
for n in sorted(names, key=lambda n: n != "mimetype"):
zi = zipfile.ZipInfo(n, date_time=z.getinfo(n).date_time)
zi.compress_type = zipfile.ZIP_STORED if n == "mimetype" or n.endswith("/") else zipfile.ZIP_DEFLATED
zi.external_attr = z.getinfo(n).external_attr
o.writestr(zi, data[n])
os.replace(tmp, dst)
return len(enc)
def selftest():
bad = 0
def check(name, got, want):
nonlocal bad
print(("ok " if got == want else "FAIL ") + name)
bad += got != want
for k, pt, ct in (("0000000000000000", "0000000000000000", "4ef997456198dd78"),
("ffffffffffffffff", "ffffffffffffffff", "51866fd5b85ecb8a"),
("3000000000000000", "1000000000000001", "7d856f9a613063f2")):
check("blowfish key " + k, Blowfish(bytes.fromhex(k)).encrypt_block(bytes.fromhex(pt)).hex(), ct)
pt = "00112233445566778899aabbccddeeff"
for k, ct in (("000102030405060708090a0b0c0d0e0f", "69c4e0d86a7b0430d8cdb78070b4c55a"),
("000102030405060708090a0b0c0d0e0f1011121314151617", "dda97ca4864cdfe06eaf70a0ec0d7191"),
("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", "8ea2b7ca516745bfeafc49904b496089")):
check("aes-%d block" % (len(k) * 2), aes_decrypt_block(aes_schedule(bytes.fromhex(k)), bytes.fromhex(ct)).hex(), pt)
msgs = [(bytes(range(256)) * 2)[:n] for n in range(0, 300) if not 52 <= n % 64 <= 55]
check("sha1_rtl equals SHA-1 outside 52..55 mod 64", all(sha1_rtl(m) == hashlib.sha1(m).digest() for m in msgs), True)
check("sha1_rtl differs from SHA-1 at 52..55 mod 64",
all(sha1_rtl(bytes(n)) != hashlib.sha1(bytes(n)).digest() for n in (52, 53, 54, 55, 116, 886)), True)
check("pbkdf2-hmac-sha1 RFC 6070", hashlib.pbkdf2_hmac("sha1", b"password", b"salt", 2, 20).hex(),
"ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957")
return bad == 0
def main(argv):
if len(argv) == 2 and argv[1] == "--selftest":
return 0 if selftest() else 1
if len(argv) != 4:
print("usage: decrypt.py <in-dir> <out-dir> <password>", file=sys.stderr)
return 2
src, dst, password = argv[1:]
os.makedirs(dst, exist_ok=True)
done = copied = 0
failed, quirks = [], 0
for name in sorted(os.listdir(src)):
path = os.path.join(src, name)
if name.startswith(".") or not os.path.isfile(path) or not zipfile.is_zipfile(path):
print("skipped (not a zip package): %s" % name)
continue
notes = []
try:
n = decrypt_package(path, os.path.join(dst, name), password, notes)
except (DecryptError, zipfile.BadZipFile, KeyError, ET.ParseError, ValueError) as e:
failed.append(name)
print("FAILED %s: %s" % (name, e), file=sys.stderr)
continue
for note in notes:
quirks += 1
print("note %s: %s" % (name, note))
if n:
done += 1
print("decrypted %s (%d encrypted entries)" % (name, n))
else:
copied += 1
print("copied %s (no encrypted entries)" % name)
print("%d decrypted, %d copied unchanged, %d failed, %d non-standard SHA-1 checksums" % (done, copied, len(failed), quirks))
return 1 if failed else 0
if __name__ == "__main__":
sys.exit(main(sys.argv))