oracle utl_encode,Oracle 加密package解密(unwrap)

最近碰到一个问题，需要解密几个使用oracle wrap加密过的程序包，查了下，已经有很多可用的程序，支持10g，11g，连12c都支持。查找过程中，花了点时间研究了下解密的过程，简单记录一下。

1. 解密算法解析

要解密，首先要了解加密的原理，在这几个版本的oracle中，解密的理论依据都来源于 "The oracle hacker's handbook" by David Litchfield 这本书，书中介绍了wrap的过程：

将源码使用lz压缩算法压缩，得到压缩串lzstr

对压缩串做sha-1运算，得到40位的哈希串shstr

将哈希串与压缩串拼在一起，shstr+lzstr

将得到的字符串再按字节执行字典表替换

再执行base64编码，就得到了加密的字符串

如果要解密加密以后的字符串，按照以上加密的过程反向推算，可以发现最关键的就是第4步中的字典表替换过程，要解决这个问题，我们就要得到这个替换的字典表，幸运的是，经过测试发现，oracle的这个字典表是固定的按字节映射，所以：

我们可以通过wrap加密一个简单字符串，比如create PACKAGE a0,得到加密后的密文，然后执行一次base64解码，就能得到替换后的字符串，代码如下

select substr(utl_encode.base64_decode(utl_raw.cast_to_raw(

rtrim(substr(wrap_text,

instr(wrap.wrap,chr(10),1,20) + 1),chr(10)))),

41) from dual

这里说明一下，wrap以后的密文里，前面20行是没有用的，密文是从第21行开始的，第21行的前40个字符，是拼接的哈希串，从第41个字符开始才是字典表转换后的密文

本例中，得到的结果为

78DA0B7074F67674775548346000001185029E

对字符串create PACKAGE a0执行lz压缩，得到字典表转换前的字符串，本例中的结果为

308399B8F5339FF5BF5C5A2170A6A6F302E141

这样我们得到了转换前和转换后的字符串，就可以按字节建立起我们需要的字典表了，比如本例中：

转换前－转换后

30 78

83 DA

依次类推，我们就可以建立起这个字典表，因为一个字节从00-FF有256个字符，所以相应的这个典表应该有256条记录，这里我们只得到了其中的一部分，还需要选用不同的字符串，多次穷举运算，最终得到全部的记录。事实上，因为这个字典表是固定的，所以得到的结果可以重复使用。当然也可以直接使用别人提供的。

有了字典表，接下来的工作就比较简单了，按照加密过程反向运算即可：

从数据库中得到package的密文

base64解码

字典表反向映射

去掉前40位哈希串

lz解压缩

2. 解密程序源码

这里贴上部分源码，供参考

LZ解压和压缩的代码，使用java source过程，为了支持比较大的package，使用CLOB作为参数类型，经测试，可以支持较大的程序包

create or replace java source named CUX_UNWRAPPER

as

import java.io.BufferedReader;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.Reader;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

import java.util.zip.Deflater;

import java.util.zip.InflaterInputStream;

import oracle.jdbc.OracleDriver;

import oracle.sql.CLOB;

public class UNWRAPPER {

//解压缩

public static CLOB Inflate(CLOB src) throws IOException, SQLException {

StringBuffer sb = new StringBuffer();

String s = src.stringValue();

try{

ByteArrayInputStream bis =

new ByteArrayInputStream(decodeHex(s.toCharArray()));

//ByteArrayInputStream bis = new ByteArrayInputStream(src);

InflaterInputStream iis = new InflaterInputStream(bis);

for (int c = iis.read(); c != -1; c = iis.read()) {

sb.append((char)c);

}

}catch (Exception e)

{

e.printStackTrace();

}

Connection conn = DriverManager.getConnection("jdbc:default:connection:");

CLOB clob = CLOB.createTemporary(conn, false, CLOB.DURATION_SESSION);

clob.setString(1, sb.toString());

return clob;

}

public static byte[] Deflate(String src, int quality) {

try {

byte[] tmp = new byte[src.length() + 100];

Deflater defl = new Deflater(quality);

defl.setInput(src.getBytes("UTF-8"));

defl.finish();

int cnt = defl.deflate(tmp);

byte[] res = new byte[cnt];

for (int i = 0; i < cnt; i++)

res = tmp;

return res;

} catch (Exception e) {

}

return null;

}

public static int toDigit(char ch, int index) {

int digit = Character.digit(ch, 16);

if (digit == -1) {

throw new RuntimeException("illegal hexadecimal character " + ch +

" at index " + index);

}

return digit;

}

//16进制字符串转字节数组

public static byte[] decodeHex(char[] data) {

int len = data.length;

if ((len & 0x01) != 0) {

throw new RuntimeException("odd number of characters ");

}

byte[] out = new byte[len >> 1];

for (int i = 0, j = 0; j < len; i++) {

int f = toDigit(data[j], j) << 4;

j++;

f = f | toDigit(data[j], j);

j++;

out[i] = (byte)(f & 0xFF);

}

return out;

}

}

/

--编译java source

alter java source CUX_UNWRAPPER compile

/

解密plsql主程序

--程序包体

create or replace package body cux_unwrapper is

function deflate(src in varchar2) return raw is

begin

return deflate(src, 6);

end;

--压缩

function deflate(src in varchar2, quality in number) return raw as

language java name 'UNWRAPPER.Deflate( java.lang.String, int ) return byte[]';

--解压缩

function inflate(src in clob) return clob as

language java name 'UNWRAPPER.Inflate( oracle.sql.CLOB ) return oracle.sql.CLOB';

--输出clob

procedure out_put(p_clob clob) is

l_len integer;

l_pos integer := 1;

l_chunk integer := 2000;

l_buffer varchar2(4000);

l_amount integer;

l_ins_pos integer := 1;

begin

l_len := dbms_lob.getlength(p_clob);

while l_pos < l_len loop

if l_len - l_pos < l_chunk then

l_ins_pos := l_len;

else

l_ins_pos := dbms_lob.instr(p_clob, chr(10), l_pos + l_chunk, 1);

end if;

l_amount := l_ins_pos - l_pos + 1;

dbms_lob.read(p_clob, l_amount, l_pos, l_buffer);

dbms_output.put_line(l_buffer);

l_pos := l_ins_pos + 1;

end loop;

end out_put;

--解密主程序

PROCEDURE unwrap(p_owner IN VARCHAR,

p_name IN VARCHAR,

p_type IN VARCHAR) AS

l_wrap varchar2(32767);

l_inf clob;

l_res clob;

l_src clob;

l_inflate varchar2(32767);

l_temp VARCHAR2(32767);

l_bt varchar2(32767);

l_text varchar2(32767);

l_char varchar2(2);

l_len number;

l_slen integer;

l_offset integer := 1;

l_chunk_len integer := 10080;

--解密字节对照字典表

l_dict varchar2(512) := '3D6585B318DBE287F152AB634BB5A05F' ||

'7D687B9B24C228678ADEA4261E03EB17' ||

'6F343E7A3FD2A96A0FE935561FB14D10' ||

'78D975F6BC4104816106F9ADD6D5297E' ||

'869E79E505BA84CC6E278EB05DA8F39F' ||

'D0A271B858DD2C38994C480755E4538C' ||

'46B62DA5AF322240DC50C3A1258B9C16' ||

'605CCFFD0C981CD4376D3C3A30E86C31' ||

'47F533DA43C8E35E1994ECE6A39514E0' ||

'9D64FA5915C52FCABB0BDFF297BF0A76' ||

'B449445A1DF0009621807F1A82394FC1' ||

'A7D70DD1D8FF139370EE5BEFBE09B977' ||

'72E7B254B72AC7739066200E51EDF87C' ||

'8F2EF412C62B83CDACCB3BC44EC06936' ||

'6202AE88FCAA4208A64557D39ABDE123' ||

'8D924A1189746B91FBFEC901EA1BF7CE';

l_sl varchar2(512) := '000102030405060708090A0B0C0D0E0F' ||

'101112131415161718191A1B1C1D1E1F' ||

'202122232425262728292A2B2C2D2E2F' ||

'303132333435363738393A3B3C3D3E3F' ||

'404142434445464748494A4B4C4D4E4F' ||

'505152535455565758595A5B5C5D5E5F' ||

'606162636465666768696A6B6C6D6E6F' ||

'707172737475767778797A7B7C7D7E7F' ||

'808182838485868788898A8B8C8D8E8F' ||

'909192939495969798999A9B9C9D9E9F' ||

'A0A1A2A3A4A5A6A7A8A9AAABACADAEAF' ||

'B0B1B2B3B4B5B6B7B8B9BABBBCBDBEBF' ||

'C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF' ||

'D0D1D2D3D4D5D6D7D8D9DADBDCDDDEDF' ||

'E0E1E2E3E4E5E6E7E8E9EAEBECEDEEEF' ||

'F0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFF';

cursor c_src is

SELECT src.line, src.text

FROM DBA_SOURCE src

WHERE owner = p_owner

AND Name = p_name

AND TYPE = p_type

order by line;

BEGIN

dbms_lob.createtemporary(lob_loc => l_inf,

cache => TRUE,

dur => dbms_lob.session);

--取得package密文

for rec in c_src loop

l_src := l_src || rtrim(rec.text);

end loop;

--out_put('source:');

l_src := rtrim(substr(l_src, instr(l_src, chr(10), 1, 20) + 1), chr(10));

l_src := replace(l_src, chr(10), '');

-- dbms_output.put_line('source:');

--l_src:=substr(l_src,41);

--base64解码

l_len := dbms_lob.getlength(l_src);

while l_offset < l_len loop

if (l_len - l_offset) < 10080 then

l_chunk_len := (l_len - l_offset);

end if;

l_temp := dbms_lob.substr(l_src, l_chunk_len, l_offset);

l_bt := utl_encode.base64_decode(utl_raw.cast_to_raw(l_temp));

if l_bt is not null then

if l_offset = 1 then

--去掉前40位哈希串

l_bt := substr(l_bt, 41);

end if;

-- l_wrap := l_wrap || l_bt;

--字典表转换

l_bt := utl_raw.translate(l_bt, l_sl, l_dict);

l_offset := l_offset + l_chunk_len;

-- l_inflate := l_inflate || l_bt;

dbms_lob.writeappend(l_inf, length(l_bt), l_bt);

end if;

end loop;

/* dbms_output.put_line('base:' || l_wrap);

dbms_output.put_line('');*/

--解压缩

l_res := inflate(l_inf);

out_put(l_res);

END unwrap;

END;

/