eTRM uses javascript that opens and focuses a separate window to display reports. Your browser does not appear to support javascript. This should not prevent you from using eTRM but it does mean the window focus feature will not work. Please check the contents of other windows on your desktop if you click on a link that does not appear to do anything.

APPS.FND_CRYPTO dependencies on UTL_RAW

Line 77: return utl_raw.bit_complement(NumToTwosComp(-(num+1)));

73: is
74: ret raw(100);
75: begin
76: if (num < 0) then
77: return utl_raw.bit_complement(NumToTwosComp(-(num+1)));
78: end if;
79: if (num < ENCNML) then
80: return to_char(mod (num,power(2,64)), NUMTOX);
81: end if;

Line 90: if (to_number(utl_raw.substr(r,1,1),'XX') >= 128) then

86: return varchar2
87: is
88: n number;
89: begin
90: if (to_number(utl_raw.substr(r,1,1),'XX') >= 128) then
91: return -TwosCompToNum(utl_raw.bit_complement(r))-1;
92: end if;
93: if (utl_raw.length(r) <= 16) then
94: return to_number(r, XTONUM);

Line 91: return -TwosCompToNum(utl_raw.bit_complement(r))-1;

87: is
88: n number;
89: begin
90: if (to_number(utl_raw.substr(r,1,1),'XX') >= 128) then
91: return -TwosCompToNum(utl_raw.bit_complement(r))-1;
92: end if;
93: if (utl_raw.length(r) <= 16) then
94: return to_number(r, XTONUM);
95: end if;

Line 93: if (utl_raw.length(r) <= 16) then

89: begin
90: if (to_number(utl_raw.substr(r,1,1),'XX') >= 128) then
91: return -TwosCompToNum(utl_raw.bit_complement(r))-1;
92: end if;
93: if (utl_raw.length(r) <= 16) then
94: return to_number(r, XTONUM);
95: end if;
96: return TwosCompToNum(utl_raw.substr(r,1,utl_raw.length(r)-16))*power(2,128)+
97: to_number(utl_raw.substr(r,-16), XTONUM);

Line 96: return TwosCompToNum(utl_raw.substr(r,1,utl_raw.length(r)-16))*power(2,128)+

92: end if;
93: if (utl_raw.length(r) <= 16) then
94: return to_number(r, XTONUM);
95: end if;
96: return TwosCompToNum(utl_raw.substr(r,1,utl_raw.length(r)-16))*power(2,128)+
97: to_number(utl_raw.substr(r,-16), XTONUM);
98: end TwosCompToNum;
99:
100: ---------------------- ENCRYPT AND DECRYPT ------------------------

Line 97: to_number(utl_raw.substr(r,-16), XTONUM);

93: if (utl_raw.length(r) <= 16) then
94: return to_number(r, XTONUM);
95: end if;
96: return TwosCompToNum(utl_raw.substr(r,1,utl_raw.length(r)-16))*power(2,128)+
97: to_number(utl_raw.substr(r,-16), XTONUM);
98: end TwosCompToNum;
99:
100: ---------------------- ENCRYPT AND DECRYPT ------------------------
101:

Line 106: pad := 8 - MOD(utl_raw.length(s),8);

102: function pkcs5pad(s raw) return raw
103: is
104: pad number;
105: begin
106: pad := 8 - MOD(utl_raw.length(s),8);
107: return utl_raw.concat(s, utl_raw.substr(PADRAW, pad*(pad-1)/2+1,pad));
108: end pkcs5pad;
109:
110: function des3e(s in raw,

Line 107: return utl_raw.concat(s, utl_raw.substr(PADRAW, pad*(pad-1)/2+1,pad));

103: is
104: pad number;
105: begin
106: pad := 8 - MOD(utl_raw.length(s),8);
107: return utl_raw.concat(s, utl_raw.substr(PADRAW, pad*(pad-1)/2+1,pad));
108: end pkcs5pad;
109:
110: function des3e(s in raw,
111: k in raw,

Line 121: t := utl_raw.bit_xor(t, '0123456789ABCDEF');

117: t := pkcs5pad(s);
118: else
119: t := s;
120: end if;
121: t := utl_raw.bit_xor(t, '0123456789ABCDEF');
122: if (i is not null) then
123: t := utl_raw.bit_xor(t, utl_raw.substr(i,1,8));
124: end if;
125: t := SYS.dbms_obfuscation_toolkit.DES3Encrypt

Line 123: t := utl_raw.bit_xor(t, utl_raw.substr(i,1,8));

119: t := s;
120: end if;
121: t := utl_raw.bit_xor(t, '0123456789ABCDEF');
122: if (i is not null) then
123: t := utl_raw.bit_xor(t, utl_raw.substr(i,1,8));
124: end if;
125: t := SYS.dbms_obfuscation_toolkit.DES3Encrypt
126: (input=>t, key=>k,
127: which=>SYS.dbms_obfuscation_toolkit.ThreeKeyMode);

Line 154: pad := TO_NUMBER(rawtohex(utl_raw.substr(s, -1)), 'XX');

150: function pkcs5unpad(s raw) return raw
151: is
152: pad number;
153: begin
154: pad := TO_NUMBER(rawtohex(utl_raw.substr(s, -1)), 'XX');
155: if (pad < 1 or pad > 8) then raise BadPadding; end if;
156:
157: if utl_raw.compare(utl_raw.substr(PADRAW, pad*(pad-1)/2+1, pad),
158: utl_raw.substr(s, -pad)) <> 0 then

Line 157: if utl_raw.compare(utl_raw.substr(PADRAW, pad*(pad-1)/2+1, pad),

153: begin
154: pad := TO_NUMBER(rawtohex(utl_raw.substr(s, -1)), 'XX');
155: if (pad < 1 or pad > 8) then raise BadPadding; end if;
156:
157: if utl_raw.compare(utl_raw.substr(PADRAW, pad*(pad-1)/2+1, pad),
158: utl_raw.substr(s, -pad)) <> 0 then
159: raise BadPadding;
160: end if;
161:

Line 158: utl_raw.substr(s, -pad)) <> 0 then

154: pad := TO_NUMBER(rawtohex(utl_raw.substr(s, -1)), 'XX');
155: if (pad < 1 or pad > 8) then raise BadPadding; end if;
156:
157: if utl_raw.compare(utl_raw.substr(PADRAW, pad*(pad-1)/2+1, pad),
158: utl_raw.substr(s, -pad)) <> 0 then
159: raise BadPadding;
160: end if;
161:
162: return utl_raw.substr(s, 1, utl_raw.length(s) - pad);

Line 162: return utl_raw.substr(s, 1, utl_raw.length(s) - pad);

158: utl_raw.substr(s, -pad)) <> 0 then
159: raise BadPadding;
160: end if;
161:
162: return utl_raw.substr(s, 1, utl_raw.length(s) - pad);
163: end pkcs5unpad;
164:
165: function des3d(s in raw,
166: k in raw,

Line 175: t := utl_raw.bit_xor(t, '0123456789ABCDEF');

171: begin
172: t := SYS.dbms_obfuscation_toolkit.DES3Decrypt
173: (input=>s, key=>k,
174: which=>SYS.dbms_obfuscation_toolkit.ThreeKeyMode);
175: t := utl_raw.bit_xor(t, '0123456789ABCDEF');
176: if (i is not null) then
177: t := utl_raw.bit_xor(t, utl_raw.substr(i,1,8));
178: end if;
179: if (upper(substr(pd,1,1)) = 'Y') then

Line 177: t := utl_raw.bit_xor(t, utl_raw.substr(i,1,8));

173: (input=>s, key=>k,
174: which=>SYS.dbms_obfuscation_toolkit.ThreeKeyMode);
175: t := utl_raw.bit_xor(t, '0123456789ABCDEF');
176: if (i is not null) then
177: t := utl_raw.bit_xor(t, utl_raw.substr(i,1,8));
178: end if;
179: if (upper(substr(pd,1,1)) = 'Y') then
180: t := pkcs5unpad(t);
181: end if;

Line 241: if (utl_raw.length(key) > 64) then

237: ipk raw(64);
238: opk raw(64);
239: hsh raw(16);
240: begin
241: if (utl_raw.length(key) > 64) then
242: ipk := SYS.dbms_obfuscation_toolkit.md5(input => key);
243: else
244: ipk := key;
245: end if;

Line 246: if (utl_raw.length(ipk) < 64) then

242: ipk := SYS.dbms_obfuscation_toolkit.md5(input => key);
243: else
244: ipk := key;
245: end if;
246: if (utl_raw.length(ipk) < 64) then
247: ipk := utl_raw.concat(ipk, rpad('0',128-2*utl_raw.length(ipk), '0'));
248: end if;
249: opk := utl_raw.bit_xor(ipk, OPAD);
250: ipk := utl_raw.bit_xor(ipk, IPAD);

Line 247: ipk := utl_raw.concat(ipk, rpad('0',128-2*utl_raw.length(ipk), '0'));

243: else
244: ipk := key;
245: end if;
246: if (utl_raw.length(ipk) < 64) then
247: ipk := utl_raw.concat(ipk, rpad('0',128-2*utl_raw.length(ipk), '0'));
248: end if;
249: opk := utl_raw.bit_xor(ipk, OPAD);
250: ipk := utl_raw.bit_xor(ipk, IPAD);
251:

Line 249: opk := utl_raw.bit_xor(ipk, OPAD);

245: end if;
246: if (utl_raw.length(ipk) < 64) then
247: ipk := utl_raw.concat(ipk, rpad('0',128-2*utl_raw.length(ipk), '0'));
248: end if;
249: opk := utl_raw.bit_xor(ipk, OPAD);
250: ipk := utl_raw.bit_xor(ipk, IPAD);
251:
252: hsh := SYS.dbms_obfuscation_toolkit.md5(input => utl_raw.concat(ipk, src));
253: hsh := SYS.dbms_obfuscation_toolkit.md5(input => utl_raw.concat(opk, hsh));

Line 250: ipk := utl_raw.bit_xor(ipk, IPAD);

246: if (utl_raw.length(ipk) < 64) then
247: ipk := utl_raw.concat(ipk, rpad('0',128-2*utl_raw.length(ipk), '0'));
248: end if;
249: opk := utl_raw.bit_xor(ipk, OPAD);
250: ipk := utl_raw.bit_xor(ipk, IPAD);
251:
252: hsh := SYS.dbms_obfuscation_toolkit.md5(input => utl_raw.concat(ipk, src));
253: hsh := SYS.dbms_obfuscation_toolkit.md5(input => utl_raw.concat(opk, hsh));
254: return hsh;

Line 252: hsh := SYS.dbms_obfuscation_toolkit.md5(input => utl_raw.concat(ipk, src));

248: end if;
249: opk := utl_raw.bit_xor(ipk, OPAD);
250: ipk := utl_raw.bit_xor(ipk, IPAD);
251:
252: hsh := SYS.dbms_obfuscation_toolkit.md5(input => utl_raw.concat(ipk, src));
253: hsh := SYS.dbms_obfuscation_toolkit.md5(input => utl_raw.concat(opk, hsh));
254: return hsh;
255: end kmd5_alg;
256:

Line 253: hsh := SYS.dbms_obfuscation_toolkit.md5(input => utl_raw.concat(opk, hsh));

249: opk := utl_raw.bit_xor(ipk, OPAD);
250: ipk := utl_raw.bit_xor(ipk, IPAD);
251:
252: hsh := SYS.dbms_obfuscation_toolkit.md5(input => utl_raw.concat(ipk, src));
253: hsh := SYS.dbms_obfuscation_toolkit.md5(input => utl_raw.concat(opk, hsh));
254: return hsh;
255: end kmd5_alg;
256:
257: FUNCTION Mac (source IN RAW,

Line 290: ret := utl_raw.concat(ret, tmp);

286: tmp := FND_RANDOM_NUMBER.GET_RANDOM_BYTES(len);
287: else
288: tmp := FND_RANDOM_NUMBER.GET_RANDOM_BYTES(2000);
289: end if;
290: ret := utl_raw.concat(ret, tmp);
291: len := len - utl_raw.length(tmp);
292: end loop;
293: return ret;
294: end RandomBytes;

Line 291: len := len - utl_raw.length(tmp);

287: else
288: tmp := FND_RANDOM_NUMBER.GET_RANDOM_BYTES(2000);
289: end if;
290: ret := utl_raw.concat(ret, tmp);
291: len := len - utl_raw.length(tmp);
292: end loop;
293: return ret;
294: end RandomBytes;
295:

Line 345: return utl_raw.cast_to_varchar2(utl_raw.reverse(numtohex(nb, 84trunc((len+2)/3))));

341: na := trunc(na / BASE64);
342: ln := ln - 1;
343: end loop;
344:
345: return utl_raw.cast_to_varchar2(utl_raw.reverse(numtohex(nb, 8*4*trunc((len+2)/3))));
346: end encodeunit;
347:
348: function encodedrop(unit in raw, len in pls_integer, mp in CharMapType)
349: return varchar2

Line 361: return utl_raw.cast_to_varchar2(utl_raw.reverse(numtohex(nb, 8*len)));

357: na := trunc(na / 256);
358: ln := ln - 1;
359: end loop;
360:
361: return utl_raw.cast_to_varchar2(utl_raw.reverse(numtohex(nb, 8*len)));
362: end encodedrop;
363:
364: function make_map_to(mapsrc in varchar2) return CharMapType
365: is

Line 367: val raw(256):= utl_raw.cast_to_raw(mapsrc);

363:
364: function make_map_to(mapsrc in varchar2) return CharMapType
365: is
366: tmp CharMapType;
367: val raw(256):= utl_raw.cast_to_raw(mapsrc);
368: begin
369: for j in 1..utl_raw.length(val) LOOP
370: tmp(j-1) := to_number(utl_raw.substr(val, j, 1),'XX');
371: end LOOP;

Line 369: for j in 1..utl_raw.length(val) LOOP

365: is
366: tmp CharMapType;
367: val raw(256):= utl_raw.cast_to_raw(mapsrc);
368: begin
369: for j in 1..utl_raw.length(val) LOOP
370: tmp(j-1) := to_number(utl_raw.substr(val, j, 1),'XX');
371: end LOOP;
372: return tmp;
373: end make_map_to;

Line 370: tmp(j-1) := to_number(utl_raw.substr(val, j, 1),'XX');

366: tmp CharMapType;
367: val raw(256):= utl_raw.cast_to_raw(mapsrc);
368: begin
369: for j in 1..utl_raw.length(val) LOOP
370: tmp(j-1) := to_number(utl_raw.substr(val, j, 1),'XX');
371: end LOOP;
372: return tmp;
373: end make_map_to;
374:

Line 378: val raw(256):= utl_raw.cast_to_raw(mapsrc);

374:
375: function make_map_from(mapsrc in varchar2) return CharMapType
376: is
377: tmp CharMapType;
378: val raw(256):= utl_raw.cast_to_raw(mapsrc);
379: begin
380: for j in 1..utl_raw.length(val) LOOP
381: tmp(to_number(utl_raw.substr(val, j, 1),'XX')) := j - 1;
382: end LOOP;

Line 380: for j in 1..utl_raw.length(val) LOOP

376: is
377: tmp CharMapType;
378: val raw(256):= utl_raw.cast_to_raw(mapsrc);
379: begin
380: for j in 1..utl_raw.length(val) LOOP
381: tmp(to_number(utl_raw.substr(val, j, 1),'XX')) := j - 1;
382: end LOOP;
383: return tmp;
384: end make_map_from;

Line 381: tmp(to_number(utl_raw.substr(val, j, 1),'XX')) := j - 1;

377: tmp CharMapType;
378: val raw(256):= utl_raw.cast_to_raw(mapsrc);
379: begin
380: for j in 1..utl_raw.length(val) LOOP
381: tmp(to_number(utl_raw.substr(val, j, 1),'XX')) := j - 1;
382: end LOOP;
383: return tmp;
384: end make_map_from;
385:

Line 403: len number := utl_raw.length(source) + 1;

399: FUNCTION Encode (source IN RAW,
400: fmt_type IN PLS_INTEGER)
401: RETURN VARCHAR2 is
402: cur number := 1;
403: len number := utl_raw.length(source) + 1;
404: nxt number := len - cur;
405: ret varchar2(32767);
406: drp boolean;
407: mp CharMapType := get_map(fmt_type, drp);

Line 412: ret := ret || encodeunit(utl_raw.substr(source, cur, nxt), nxt, mp);

408: begin
409: while (nxt > 0) loop
410: if (nxt > 12) then nxt := 12; end if;
411: if (not drp) then
412: ret := ret || encodeunit(utl_raw.substr(source, cur, nxt), nxt, mp);
413: else
414: ret := ret || encodedrop(utl_raw.substr(source, cur, nxt), nxt, mp);
415: end if;
416: cur := cur + nxt;

Line 414: ret := ret || encodedrop(utl_raw.substr(source, cur, nxt), nxt, mp);

410: if (nxt > 12) then nxt := 12; end if;
411: if (not drp) then
412: ret := ret || encodeunit(utl_raw.substr(source, cur, nxt), nxt, mp);
413: else
414: ret := ret || encodedrop(utl_raw.substr(source, cur, nxt), nxt, mp);
415: end if;
416: cur := cur + nxt;
417: nxt := len - cur;
418: end loop;

Line 425: na number := to_number(utl_raw.reverse(utl_raw.cast_to_raw(unit)),'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX');

421:
422: function decodeunit(unit in varchar2, mp in CharMapType)
423: return raw
424: is
425: na number := to_number(utl_raw.reverse(utl_raw.cast_to_raw(unit)),'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX');
426: nb number := 0;
427: nc number;
428: ln pls_integer := 0;
429: begin

Line 453: na number := to_number(utl_raw.reverse(utl_raw.cast_to_raw(unit)),'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX');

449:
450: function decodedrop(unit in varchar2, mp in CharMapType)
451: return raw
452: is
453: na number := to_number(utl_raw.reverse(utl_raw.cast_to_raw(unit)),'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX');
454: nb number := 0;
455: ln pls_integer := 0;
456: begin
457: while (na > 0) loop