diff options
Diffstat (limited to 'tools/4/source/src/main.cpp')
| -rw-r--r-- | tools/4/source/src/main.cpp | 1782 |
1 files changed, 1782 insertions, 0 deletions
diff --git a/tools/4/source/src/main.cpp b/tools/4/source/src/main.cpp new file mode 100644 index 0000000..21b8f9c --- /dev/null +++ b/tools/4/source/src/main.cpp @@ -0,0 +1,1782 @@ +#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <time.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#define IDPS_KEYBITS 128
+#define ACT_DAT_KEYBITS 128
+#define RIF_KEYBITS 128
+#define RAP_KEYBITS 128
+#include "aes.h"
+#include "util.h"
+#include "sha1.h"
+#include "pkg2zip_aes.h"
+
+#ifdef _WIN32
+#define fseek _fseeki64
+#define ftell _ftelli64
+#endif
+
+#define _LARGEFILE64_SOURCE
+#define _FILE_OFFSET_BITS 64
+
+uint8_t p_fixed[20]={0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
+uint8_t a_fixed[20]={0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFC};
+uint8_t b_fixed[20]={0xA6,0x8B,0xED,0xC3,0x34,0x18,0x02,0x9C,0x1D,0x3C,0xE3,0x3B,0x9A,0x32,0x1F,0xCC,0xBB,0x9E,0x0F,0x0B};
+uint8_t n_fixed[21]={0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0xFF,0xFF,0xB5,0xAE,0x3C,0x52,0x3E,0x63,0x94,0x4F,0x21,0x27};
+uint8_t gx_fixed[20]={0x12,0x8E,0xC4,0x25,0x64,0x87,0xFD,0x8F,0xDF,0x64,0xE2,0x43,0x7B,0xC0,0xA1,0xF6,0xD5,0xAF,0xDE,0x2C};
+uint8_t gy_fixed[20]={0x59,0x58,0x55,0x7E,0xB1,0xDB,0x00,0x12,0x60,0x42,0x55,0x24,0xDB,0xC3,0x79,0xD5,0xAC,0x5F,0x4A,0xDF};
+
+uint8_t ec_p_nm[20]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x4A, 0x51, 0xC3, 0xAD, 0xC1, 0x9C, 0x6B, 0xB0, 0xDE, 0xD8};
+uint8_t ec_a_nm[20]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF ,0xFF ,0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+uint8_t ec_b_nm[20]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03};
+uint8_t ec_G_nm[40]={0xED, 0x71, 0x3B, 0xDA, 0x9B, 0x78, 0x02, 0x70, 0x20, 0x9B, 0x1D, 0xBC, 0x84, 0x3F, 0x5E, 0x09, 0x2A, 0x50, 0x21, 0xD3, 0xA6, 0xA7, 0xAA, 0x81, 0x4E, 0x24, 0xFF, 0xED, 0x9F, 0xBD, 0xAA, 0xDB, 0x24, 0x3C, 0x86, 0x2A, 0x53, 0xA0, 0xB5, 0x20};
+uint8_t ec_N_nm[20]={0x59, 0x74, 0x12, 0x3C, 0xCB, 0xE7, 0xFD, 0x63, 0xE2, 0xC3, 0x1C, 0xC4, 0x65, 0xCD, 0xE0, 0x33, 0x44, 0x61 ,0xF0, 0xF4};
+
+//uint8_t ec_k[21]={0x00,0x42,0x75,0x72,0x6E,0x20,0x49,0x6E,0x20,0x48,0x65,0x6C,0x6C,0x20,0x53,0x6F,0x6E,0x79,0x20,0x21,0x21};
+//uint8_t ec_Q_nm[40]={0x7C,0xFD,0x88,0x8E,0xE9,0xDD,0x5F,0x60,0x30,0xA5,0xC1,0xC0,0xA2,0xF9,0x08,0x4A,0x74,0xB1,0x32,0x87,0x33,0x52,0x68,0x11,0xCF,0xBA,0x95,0x35,0x06,0xE4,0x41,0x11,0xF0,0xE2,0xD6,0xF2,0xD1,0x91,0x3E,0x69};
+
+uint8_t ec_k[21]={0x00,0xbf,0x21,0x22,0x4b,0x04,0x1f,0x29,0x54,0x9d,0xb2,0x5e,0x9a,0xad,0xe1,0x9e,0x72,0x0a,0x1f,0xe0,0xf1};
+uint8_t ec_Q_nm[40]={0x94,0x8D,0xA1,0x3E,0x8C,0xAF,0xD5,0xBA,0x0E,0x90,0xCE,0x43,0x44,0x61,0xBB,0x32,0x7F,0xE7,0xE0,0x80,0x47,0x5E,0xAA,0x0A,0xD3,0xAD,0x4F,0x5B,0x62,0x47,0xA7,0xFD,0xA8,0x6D,0xF6,0x97,0x90,0x19,0x67,0x73};
+
+struct point {
+ u8 x[20];
+ u8 y[20];
+};
+
+
+static uint8_t ec_p[20];
+static uint8_t ec_a[20];
+static uint8_t ec_b[20];
+static point ec_G;
+static point ec_Q;
+static uint8_t ec_N[21];
+
+#define MT_N 624
+#define MT_M 397
+#define MT_MATRIX_A 0x9908b0df
+#define MT_UPPER_MASK 0x80000000
+#define MT_LOWER_MASK 0x7fffffff
+
+/*! Mersenne-Twister 19937 context. */
+typedef struct _mt19937_ctxt
+{
+ /*! State. */
+ unsigned int state[MT_N];
+ /*! Index. */
+ unsigned int idx;
+} mt19937_ctxt_t;
+
+void mt19937_init(mt19937_ctxt_t *ctxt, unsigned int seed)
+{
+ ctxt->state[0] = seed;
+
+ for(ctxt->idx = 1; ctxt->idx < MT_N; ctxt->idx++)
+ ctxt->state[ctxt->idx] = (1812433253 * (ctxt->state[ctxt->idx - 1] ^ (ctxt->state[ctxt->idx - 1] >> 30)) + ctxt->idx);
+
+ ctxt->idx = MT_M + 1;
+}
+
+unsigned int mt19937_update(mt19937_ctxt_t *ctxt)
+{
+ unsigned int y, k;
+ static unsigned int mag01[2] = {0, MT_MATRIX_A};
+
+ if(ctxt->idx >= MT_N)
+ {
+ for(k = 0; k < MT_N - MT_M; k++)
+ {
+ y = (ctxt->state[k] & MT_UPPER_MASK) |
+ (ctxt->state[k + 1] & MT_LOWER_MASK);
+ ctxt->state[k] = ctxt->state[k + MT_M] ^ (y >> 1) ^ mag01[y & 1];
+ }
+
+ for(; k < MT_N - 1; k++)
+ {
+ y = (ctxt->state[k] & MT_UPPER_MASK) |
+ (ctxt->state[k + 1] & MT_LOWER_MASK);
+ ctxt->state[k] = ctxt->state[k + (MT_M - MT_N)] ^ (y >> 1) ^ mag01[y & 1];
+ }
+
+ y = (ctxt->state[MT_N - 1] & MT_UPPER_MASK) |
+ (ctxt->state[0] & MT_LOWER_MASK);
+ ctxt->state[MT_N - 1] = ctxt->state[MT_M - 1] ^ (y >> 1) ^ mag01[y & 1];
+
+ ctxt->idx = 0;
+ }
+
+ y = ctxt->state[ctxt->idx++];
+
+ y ^= (y >> 11);
+ y ^= (y << 7) & 0x9d2c5680UL;
+ y ^= (y << 15) & 0xefc60000UL;
+ y ^= (y >> 18);
+
+ return y;
+}
+
+static mt19937_ctxt_t _mt19937_ctxt;
+static BOOL _mt_init = FALSE;
+
+u8 _get_rand_byte()
+{
+ if(_mt_init == FALSE)
+ {
+ _mt_init = TRUE;
+ mt19937_init(&_mt19937_ctxt, clock());
+ }
+
+ return (u8)(mt19937_update(&_mt19937_ctxt) & 0xFF);
+}
+
+void _fill_rand_bytes(u8 *dst, u32 len)
+{
+ u32 i;
+
+ for(i = 0; i < len; i++)
+ dst[i] = _get_rand_byte();
+}
+
+static void memcpy_inv(u8 *dst, u8 *src, u32 len)
+{
+ u32 j;
+
+ for (j = 0; j < len; j++)
+ dst[j] = ~src[j];
+}
+
+void bn_print(char *name, u8 *a, u32 n)
+{
+ u32 i;
+
+ printf("%s = ", name);
+
+ for (i = 0; i < n; i++)
+ printf("%02x", a[i]);
+
+ printf("\n");
+}
+
+static void bn_zero(u8 *d, u32 n)
+{
+ memset(d, 0, n);
+}
+
+void bn_copy(u8 *d, u8 *a, u32 n)
+{
+ memcpy(d, a, n);
+}
+
+int bn_compare(u8 *a, u8 *b, u32 n)
+{
+ u32 i;
+
+ for (i = 0; i < n; i++) {
+ if (a[i] < b[i])
+ return -1;
+ if (a[i] > b[i])
+ return 1;
+ }
+
+ return 0;
+}
+
+static u8 bn_add_1(u8 *d, u8 *a, u8 *b, u32 n)
+{
+ u32 i;
+ u32 dig;
+ u8 c;
+
+ c = 0;
+ for (i = n - 1; i < n; i--) {
+ dig = a[i] + b[i] + c;
+ c = dig >> 8;
+ d[i] = dig;
+ }
+
+ return c;
+}
+
+static u8 bn_sub_1(u8 *d, u8 *a, u8 *b, u32 n)
+{
+ u32 i;
+ u32 dig;
+ u8 c;
+
+ c = 1;
+ for (i = n - 1; i < n; i--) {
+ dig = a[i] + 255 - b[i] + c;
+ c = dig >> 8;
+ d[i] = dig;
+ }
+
+ return 1 - c;
+}
+
+void bn_reduce(u8 *d, u8 *N, u32 n)
+{
+ if (bn_compare(d, N, n) >= 0)
+ bn_sub_1(d, d, N, n);
+}
+
+void bn_add(u8 *d, u8 *a, u8 *b, u8 *N, u32 n)
+{
+ if (bn_add_1(d, a, b, n))
+ bn_sub_1(d, d, N, n);
+
+ bn_reduce(d, N, n);
+}
+
+void bn_sub(u8 *d, u8 *a, u8 *b, u8 *N, u32 n)
+{
+ if (bn_sub_1(d, a, b, n))
+ bn_add_1(d, d, N, n);
+}
+
+static const u8 inv256[0x80] = {
+ 0x01, 0xab, 0xcd, 0xb7, 0x39, 0xa3, 0xc5, 0xef,
+ 0xf1, 0x1b, 0x3d, 0xa7, 0x29, 0x13, 0x35, 0xdf,
+ 0xe1, 0x8b, 0xad, 0x97, 0x19, 0x83, 0xa5, 0xcf,
+ 0xd1, 0xfb, 0x1d, 0x87, 0x09, 0xf3, 0x15, 0xbf,
+ 0xc1, 0x6b, 0x8d, 0x77, 0xf9, 0x63, 0x85, 0xaf,
+ 0xb1, 0xdb, 0xfd, 0x67, 0xe9, 0xd3, 0xf5, 0x9f,
+ 0xa1, 0x4b, 0x6d, 0x57, 0xd9, 0x43, 0x65, 0x8f,
+ 0x91, 0xbb, 0xdd, 0x47, 0xc9, 0xb3, 0xd5, 0x7f,
+ 0x81, 0x2b, 0x4d, 0x37, 0xb9, 0x23, 0x45, 0x6f,
+ 0x71, 0x9b, 0xbd, 0x27, 0xa9, 0x93, 0xb5, 0x5f,
+ 0x61, 0x0b, 0x2d, 0x17, 0x99, 0x03, 0x25, 0x4f,
+ 0x51, 0x7b, 0x9d, 0x07, 0x89, 0x73, 0x95, 0x3f,
+ 0x41, 0xeb, 0x0d, 0xf7, 0x79, 0xe3, 0x05, 0x2f,
+ 0x31, 0x5b, 0x7d, 0xe7, 0x69, 0x53, 0x75, 0x1f,
+ 0x21, 0xcb, 0xed, 0xd7, 0x59, 0xc3, 0xe5, 0x0f,
+ 0x11, 0x3b, 0x5d, 0xc7, 0x49, 0x33, 0x55, 0xff,
+};
+
+static void bn_mon_muladd_dig(u8 *d, u8 *a, u8 b, u8 *N, u32 n)
+{
+ u32 dig;
+ u32 i;
+
+ u8 z = -(d[n-1] + a[n-1]*b) * inv256[N[n-1]/2];
+
+ dig = d[n-1] + a[n-1]*b + N[n-1]*z;
+ dig >>= 8;
+
+ for (i = n - 2; i < n; i--) {
+ dig += d[i] + a[i]*b + N[i]*z;
+ d[i+1] = dig;
+ dig >>= 8;
+ }
+
+ d[0] = dig;
+ dig >>= 8;
+
+ if (dig)
+ bn_sub_1(d, d, N, n);
+
+ bn_reduce(d, N, n);
+}
+
+void bn_mon_mul(u8 *d, u8 *a, u8 *b, u8 *N, u32 n)
+{
+ u8 t[512];
+ u32 i;
+
+ bn_zero(t, n);
+
+ for (i = n - 1; i < n; i--)
+ bn_mon_muladd_dig(t, a, b[i], N, n);
+
+ bn_copy(d, t, n);
+}
+
+void bn_to_mon(u8 *d, u8 *N, u32 n)
+{
+ u32 i;
+
+ for (i = 0; i < 8*n; i++)
+ bn_add(d, d, d, N, n);
+}
+
+void bn_from_mon(u8 *d, u8 *N, u32 n)
+{
+ u8 t[512];
+
+ bn_zero(t, n);
+ t[n-1] = 1;
+ bn_mon_mul(d, d, t, N, n);
+}
+
+static void bn_mon_exp(u8 *d, u8 *a, u8 *N, u32 n, u8 *e, u32 en)
+{
+ u8 t[512];
+ u32 i;
+ u8 mask;
+
+ bn_zero(d, n);
+ d[n-1] = 1;
+ bn_to_mon(d, N, n);
+
+ for (i = 0; i < en; i++)
+ for (mask = 0x80; mask != 0; mask >>= 1) {
+ bn_mon_mul(t, d, d, N, n);
+ if ((e[i] & mask) != 0)
+ bn_mon_mul(d, t, a, N, n);
+ else
+ bn_copy(d, t, n);
+ }
+}
+
+static void elt_copy(u8 *d, u8 *a)
+{
+ memcpy(d, a, 20);
+}
+
+static void elt_zero(u8 *d)
+{
+ memset(d, 0, 20);
+}
+
+static int elt_is_zero(u8 *d)
+{
+ u32 i;
+
+ for (i = 0; i < 20; i++)
+ if (d[i] != 0)
+ return 0;
+
+ return 1;
+}
+
+static void elt_add(u8 *d, u8 *a, u8 *b)
+{
+ bn_add(d, a, b, ec_p, 20);
+}
+
+static void elt_sub(u8 *d, u8 *a, u8 *b)
+{
+ bn_sub(d, a, b, ec_p, 20);
+}
+
+static void elt_mul(u8 *d, u8 *a, u8 *b)
+{
+ bn_mon_mul(d, a, b, ec_p, 20);
+}
+
+static void elt_square(u8 *d, u8 *a)
+{
+ elt_mul(d, a, a);
+}
+
+void bn_mon_inv(u8 *d, u8 *a, u8 *N, u32 n)
+{
+ u8 t[512], s[512];
+
+ bn_zero(s, n);
+ s[n-1] = 2;
+ bn_sub_1(t, N, s, n);
+ bn_mon_exp(d, a, N, n, t, n);
+}
+
+static void elt_inv(u8 *d, u8 *a)
+{
+ u8 s[20];
+ elt_copy(s, a);
+ bn_mon_inv(d, s, ec_p, 20);
+}
+
+static void point_to_mon(struct point *p)
+{
+ bn_to_mon(p->x, ec_p, 20);
+ bn_to_mon(p->y, ec_p, 20);
+}
+
+static void point_from_mon(struct point *p)
+{
+ bn_from_mon(p->x, ec_p, 20);
+ bn_from_mon(p->y, ec_p, 20);
+}
+
+static void point_zero(struct point *p)
+{
+ elt_zero(p->x);
+ elt_zero(p->y);
+}
+
+static int point_is_zero(struct point *p)
+{
+ return elt_is_zero(p->x) && elt_is_zero(p->y);
+}
+
+static void point_double(struct point *r, struct point *p)
+{
+ u8 s[20], t[20];
+ struct point pp;
+ u8 *px, *py, *rx, *ry;
+
+ pp = *p;
+
+ px = pp.x;
+ py = pp.y;
+ rx = r->x;
+ ry = r->y;
+
+ if (elt_is_zero(py)) {
+ point_zero(r);
+ return;
+ }
+
+ elt_square(t, px); // t = px*px
+ elt_add(s, t, t); // s = 2*px*px
+ elt_add(s, s, t); // s = 3*px*px
+ elt_add(s, s, ec_a); // s = 3*px*px + a
+ elt_add(t, py, py); // t = 2*py
+ elt_inv(t, t); // t = 1/(2*py)
+ elt_mul(s, s, t); // s = (3*px*px+a)/(2*py)
+
+ elt_square(rx, s); // rx = s*s
+ elt_add(t, px, px); // t = 2*px
+ elt_sub(rx, rx, t); // rx = s*s - 2*px
+
+ elt_sub(t, px, rx); // t = -(rx-px)
+ elt_mul(ry, s, t); // ry = -s*(rx-px)
+ elt_sub(ry, ry, py); // ry = -s*(rx-px) - py
+}
+
+static void point_add(struct point *r, struct point *p, struct point *q)
+{
+ u8 s[20], t[20], u[20];
+ u8 *px, *py, *qx, *qy, *rx, *ry;
+ struct point pp, qq;
+
+ pp = *p;
+ qq = *q;
+
+ px = pp.x;
+ py = pp.y;
+ qx = qq.x;
+ qy = qq.y;
+ rx = r->x;
+ ry = r->y;
+
+ if (point_is_zero(&pp)) {
+ elt_copy(rx, qx);
+ elt_copy(ry, qy);
+ return;
+ }
+
+ if (point_is_zero(&qq)) {
+ elt_copy(rx, px);
+ elt_copy(ry, py);
+ return;
+ }
+
+ elt_sub(u, qx, px);
+
+ if (elt_is_zero(u)) {
+ elt_sub(u, qy, py);
+ if (elt_is_zero(u))
+ point_double(r, &pp);
+ else
+ point_zero(r);
+
+ return;
+ }
+
+ elt_inv(t, u); // t = 1/(qx-px)
+ elt_sub(u, qy, py); // u = qy-py
+ elt_mul(s, t, u); // s = (qy-py)/(qx-px)
+
+ elt_square(rx, s); // rx = s*s
+ elt_add(t, px, qx); // t = px+qx
+ elt_sub(rx, rx, t); // rx = s*s - (px+qx)
+
+ elt_sub(t, px, rx); // t = -(rx-px)
+ elt_mul(ry, s, t); // ry = -s*(rx-px)
+ elt_sub(ry, ry, py); // ry = -s*(rx-px) - py
+}
+
+static void point_mul(struct point *d, u8 *a, struct point *b) // a is bignum
+{
+ u32 i;
+ u8 mask;
+
+ point_zero(d);
+
+ for (i = 0; i < 21; i++)
+ for (mask = 0x80; mask != 0; mask >>= 1) {
+ point_double(d, d);
+ if ((a[i] & mask) != 0)
+ point_add(d, d, b);
+ }
+}
+
+static void generate_ecdsa(u8 *R, u8 *S, u8 *k, u8 *hash)
+{
+ u8 e[21];
+ u8 kk[21];
+ u8 m[21];
+ u8 minv[21];
+ struct point mG;
+
+ e[0] = 0;
+ memcpy(e + 1, hash, 20);
+ bn_reduce(e, ec_N, 21);
+
+try_again:
+ _fill_rand_bytes(m, 21);
+ m[0] = 0;
+ if (bn_compare(m, ec_N, 21) >= 0)
+ goto try_again;
+
+ // R = (mG).x
+ point_mul(&mG, m, &ec_G);
+ point_from_mon(&mG);
+ R[0] = 0;
+ elt_copy(R+1, mG.x);
+
+ // S = m**-1*(e + Rk) (mod N)
+
+ bn_copy(kk, k, 21);
+ bn_reduce(kk, ec_N, 21);
+ bn_to_mon(m, ec_N, 21);
+ bn_to_mon(e, ec_N, 21);
+ bn_to_mon(R, ec_N, 21);
+ bn_to_mon(kk, ec_N, 21);
+
+ bn_mon_mul(S, R, kk, ec_N, 21);
+ bn_add(kk, S, e, ec_N, 21);
+ bn_mon_inv(minv, m, ec_N, 21);
+ bn_mon_mul(S, minv, kk, ec_N, 21);
+
+ bn_from_mon(R, ec_N, 21);
+ bn_from_mon(S, ec_N, 21);
+}
+
+int set_vsh_curve(u8 *p, u8 *a, u8 *b, u8 *N, u8 *Gx, u8 *Gy)
+{
+ memcpy(p,p_fixed, 20);
+ memcpy(a, a_fixed, 20);
+ memcpy(b, b_fixed, 20);
+ memcpy(N, n_fixed, 21);
+ memcpy(Gx, gx_fixed, 20);
+ memcpy(Gy, gy_fixed, 20);
+
+ return 0;
+}
+
+int ecdsa_set_curve()
+{
+ set_vsh_curve(ec_p, ec_a, ec_b, ec_N, ec_G.x, ec_G.y);
+ bn_to_mon(ec_a, ec_p, 20);
+ bn_to_mon(ec_b, ec_p, 20);
+
+ point_to_mon(&ec_G);
+ return 0;
+}
+
+void ecdsa_set_pub()
+{
+ memcpy(ec_Q.x, ec_Q_nm,20);
+ memcpy(ec_Q.y, ec_Q_nm+20,20);
+ point_to_mon(&ec_Q);
+}
+
+void ecdsa_set_priv()
+{
+ //ec_k already set
+}
+
+static int check_ecdsa(struct point *Q, u8 *R, u8 *S, u8 *hash)
+{
+ u8 Sinv[21];
+ u8 e[21];
+ u8 w1[21], w2[21];
+ struct point r1, r2;
+ u8 rr[21];
+
+ e[0] = 0;
+ memcpy(e + 1, hash, 20);
+ bn_reduce(e, ec_N, 21);
+
+ bn_to_mon(R, ec_N, 21);
+ bn_to_mon(S, ec_N, 21);
+ bn_to_mon(e, ec_N, 21);
+
+ bn_mon_inv(Sinv, S, ec_N, 21);
+
+ bn_mon_mul(w1, e, Sinv, ec_N, 21);
+ bn_mon_mul(w2, R, Sinv, ec_N, 21);
+
+ bn_from_mon(w1, ec_N, 21);
+ bn_from_mon(w2, ec_N, 21);
+
+ point_mul(&r1, w1, &ec_G);
+ point_mul(&r2, w2, Q);
+
+ point_add(&r1, &r1, &r2);
+
+ point_from_mon(&r1);
+
+ rr[0] = 0;
+ memcpy(rr + 1, r1.x, 20);
+ bn_reduce(rr, ec_N, 21);
+
+ bn_from_mon(R, ec_N, 21);
+ bn_from_mon(S, ec_N, 21);
+
+ return (bn_compare(rr, R, 21) == 0);
+}
+
+void ecdsa_sign(u8 *hash, u8 *R, u8 *S)
+{
+ generate_ecdsa(R, S, ec_k, hash);
+}
+
+//! Byte swap unsigned short
+uint16_t swap_uint16( uint16_t val )
+{
+ return (val << 8) | (val >> 8 );
+}
+
+//! Byte swap short
+int16_t swap_int16( int16_t val )
+{
+ return (val << 8) | ((val >> 8) & 0xFF);
+}
+
+//! Byte swap unsigned int
+uint32_t swap_uint32( uint32_t val )
+{
+ val = ((val << 8) & 0xFF00FF00 ) | ((val >> 8) & 0xFF00FF );
+ return (val << 16) | (val >> 16);
+}
+
+//! Byte swap int
+int32_t swap_int32( int32_t val )
+{
+ val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF );
+ return (val << 16) | ((val >> 16) & 0xFFFF);
+}
+
+int64_t swap_int64( int64_t val )
+{
+ val = ((val << 8) & 0xFF00FF00FF00FF00ULL ) | ((val >> 8) & 0x00FF00FF00FF00FFULL );
+ val = ((val << 16) & 0xFFFF0000FFFF0000ULL ) | ((val >> 16) & 0x0000FFFF0000FFFFULL );
+ return (val << 32) | ((val >> 32) & 0xFFFFFFFFULL);
+}
+
+uint64_t swap_uint64( uint64_t val )
+{
+ val = ((val << 8) & 0xFF00FF00FF00FF00ULL ) | ((val >> 8) & 0x00FF00FF00FF00FFULL );
+ val = ((val << 16) & 0xFFFF0000FFFF0000ULL ) | ((val >> 16) & 0x0000FFFF0000FFFFULL );
+ return (val << 32) | (val >> 32);
+}
+
+long long current_timestamp() {
+ struct timeval te;
+ gettimeofday(&te, NULL); // get current time
+ long long milliseconds = te.tv_sec*1000LL + te.tv_usec/1000; // calculate milliseconds
+ // printf("milliseconds: %lld\n", milliseconds);
+ return milliseconds;
+}
+
+FILE *forge_act_dat()
+{
+ uint64_t timestamp=current_timestamp(); //today
+ uint32_t version=1;
+ version=swap_uint32(version);
+ uint32_t unk=2;
+ unk=swap_uint32(unk);
+ uint64_t psn_id=2;
+ psn_id=swap_uint64(psn_id);
+ timestamp=swap_uint64(timestamp);
+ FILE *fp=fopen("act.dat","wb");
+ uint8_t *act_dat=new uint8_t[0x1038];
+ memset(act_dat,0x11, 0x1038);
+ memcpy(act_dat, &version, 4);
+ memcpy(act_dat+4, &unk,4);
+ memcpy(act_dat+8, &psn_id, 8);
+ memcpy(act_dat+0x870, ×tamp, 8);
+ fwrite(act_dat, 0x1038,1,fp);
+ fclose(fp);
+ return fp=fopen("act.dat", "rb");
+}
+
+int read_act_dat_and_make_rif(char *path)
+{
+ char *content_id=(char *)malloc(256);
+ memset(content_id,0,256);
+ strcpy(content_id, path);
+ char *slash2 = strrchr (content_id, '\\');
+ if (slash2 != NULL)
+ {
+ *slash2 = '\0';
+ content_id=slash2+1;
+ }
+
+ char *slash_rev = strrchr (content_id, '/');
+ if (slash_rev != NULL)
+ {
+ *slash_rev = '\0';
+ content_id=slash_rev+1;
+ }
+
+ char *lastdot = strrchr (content_id, '.');
+ if (lastdot != NULL)
+ *lastdot = '\0';
+
+
+ uint8_t idps[0x10];
+ aes_context aes_ctxt;
+ uint8_t idps_const[0x10]={0x5E,0x06,0xE0,0x4F,0xD9,0x4A,0x71,0xBF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
+ uint8_t rif_key_const[0x10]={0xDA,0x7D,0x4B,0x5E,0x49,0x9A,0x4F,0x53,0xB1,0xC1,0xA1,0x4A,0x74,0x84,0x44,0x3B};
+ printf("reading:idps.hex\n");
+ FILE *fp=fopen("idps.hex", "rb");
+ if(!fp)
+ {
+ return -1;
+ }
+ fread(idps, 0x10, 1, fp);
+ fclose(fp);
+ uint8_t act_dat_key[0x10];
+ uint8_t klicensee[0x10];
+ uint8_t klicensee_enc_rif[0x10];
+ uint8_t rap[0x10];
+ uint64_t account_id;
+ //uint8_t rifkey[0x10];
+ fp=fopen("act.dat","rb");
+ if(!fp)
+ {
+ // fp=forge_act_dat();
+ return -1;
+ }
+ printf("reading:act.dat\n");
+ fseek(fp,0x8,SEEK_SET);
+ fread(&account_id, 8,1,fp);//skip aa account need
+ fseek(fp,0x10,SEEK_SET);
+ fread(act_dat_key, 0x10,1,fp); //copy first key in primary table of act.dat
+ fclose(fp);
+
+ printf("reading:%s\n", path);
+ fp=fopen(path, "rb");
+ if(!fp)
+ {
+ return -1;
+ }
+ fread(rap, 0x10,1,fp);
+ fclose(fp);
+ uint8_t *rif=(uint8_t *)malloc(0x200);
+ memset(rif,0,0x200);
+
+ get_rif_key(rap, rif+0x50); //convert rap to rifkey(klicensee)
+ aes_setkey_enc(&aes_ctxt, idps, IDPS_KEYBITS);
+ aes_crypt_ecb(&aes_ctxt, AES_ENCRYPT, idps_const, idps_const);
+
+ aes_setkey_dec(&aes_ctxt, idps_const, IDPS_KEYBITS);
+ aes_crypt_ecb(&aes_ctxt, AES_DECRYPT, act_dat_key, act_dat_key);
+
+
+ aes_setkey_enc(&aes_ctxt, act_dat_key, ACT_DAT_KEYBITS);
+ aes_crypt_ecb(&aes_ctxt, AES_ENCRYPT, rif+0x50, rif+0x50);//encrypt rif with act.dat first key primary key table
+
+ uint8_t index_act_key[4]={0};//very first key in act.dat primary table
+ uint8_t index_act_key_enc[0x10];
+ aes_setkey_enc(&aes_ctxt, rif_key_const, RIF_KEYBITS);
+ aes_crypt_ecb(&aes_ctxt, AES_ENCRYPT, rif+0x40, rif+0x40);
+ uint64_t timestamp=current_timestamp(); //today
+ timestamp=swap_uint64(timestamp);
+ uint32_t version_number=1;
+ version_number=swap_uint32(version_number);
+ uint32_t license_type=0x00010002;
+ license_type=swap_uint32(license_type);
+ uint64_t expiration_time=0;
+ expiration_time=swap_uint64(expiration_time);
+ memcpy(rif, &version_number,4);
+ memcpy(rif+4, &license_type,4);
+ memcpy(rif+8,&account_id,8);
+ memcpy(rif+0x10, content_id, 0x24);
+// memcpy(rif+0x40, index_act_key_enc, 0x10);
+// memcpy(rif+0x50, klicensee_enc_rif,0x10);
+ memcpy(rif+0x60, ×tamp, 8);
+ memcpy(rif+0x68, &expiration_time,8);
+ uint8_t sha1_digest[20];
+ sha1(rif, 0x70,sha1_digest);
+ ecdsa_set_curve();
+ ecdsa_set_pub();
+ ecdsa_set_priv();
+ uint8_t R[0x15];
+ uint8_t S[0x15];
+ ecdsa_sign(sha1_digest, R, S);
+ memcpy(rif+0x70, R+1, 0x14);
+ memcpy(rif+0x70+0x14, S+1, 0x14);
+ sha1(rif, 0xa0,sha1_digest);
+ memcpy(rif+0xa0, sha1_digest,0x10);
+ memcpy(rif+0xb0, sha1_digest,0x10);
+ memset(rif+0xc0, 0, 0x40);
+ _fill_rand_bytes(rif+0x100, 0x100);
+
+ strcpy(path+strlen(path)-4, ".rif");
+ printf("writing:%s\n", path);
+ fp=fopen(path, "wb");
+ fwrite(rif, 0x98,1,fp); //only needed till here
+ fclose(fp);
+ return 0;
+}
+
+int read_rif_key(char *content_id, uint8_t *rifkey)
+{
+ uint8_t idps[0x10];
+ aes_context aes_ctxt;
+ uint8_t idps_const[0x10]={0x5E,0x06,0xE0,0x4F,0xD9,0x4A,0x71,0xBF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
+ uint8_t rif_key_const[0x10]={0xDA,0x7D,0x4B,0x5E,0x49,0x9A,0x4F,0x53,0xB1,0xC1,0xA1,0x4A,0x74,0x84,0x44,0x3B};
+ printf("reading:idps.hex\n");
+ FILE *fp=fopen("idps.hex", "rb");
+ if(!fp)
+ {
+ return -1;
+ }
+ fread(idps, 0x10, 1, fp);
+ fclose(fp);
+ uint8_t act_dat_key[0x10];
+ uint8_t klicensee[0x10];
+ uint8_t klicensee_enc_rif[0x10];
+ uint8_t rap[0x10];
+ fp=fopen("act.dat","rb");
+ if(!fp)
+ {
+ return -1;
+ }
+ printf("reading:act.dat\n");
+ fseek(fp,0x8,SEEK_SET);
+ fseek(fp,0x10,SEEK_SET);
+ fread(act_dat_key, 0x10,1,fp); //copy first key in primary table of act.dat
+ fclose(fp);
+ char rap_path[0x80];
+ strcpy(rap_path, content_id);
+ strcat(rap_path, ".rap");
+ printf("reading:%s\n", rap_path);
+ fp=fopen(rap_path, "rb");
+ if(!fp)
+ {
+ return -1;
+ }
+ fread(rap, 0x10,1,fp);
+ fclose(fp);
+ uint8_t *rif=(uint8_t *)malloc(0x200);
+ memset(rif,0,0x200);
+
+ get_rif_key(rap, rifkey); //convert rap to rifkey(klicensee)
+ return 0;
+}
+
+u8 ps2_iv[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+
+int sign_act_dat()
+{
+ uint8_t *act_dat_buf=(uint8_t *)malloc(0x2000);
+ printf("reading:act.dat\n");
+ FILE *fp=fopen("act.dat","rb");
+ fread(act_dat_buf, 0x1038,1,fp);
+ fclose(fp);
+ uint8_t digest[20];
+ sha1(act_dat_buf, 0x1010, digest);
+ uint8_t R[0x15];
+ uint8_t S[0x15];
+ ecdsa_sign(digest, R,S);
+ memcpy(act_dat_buf+0x1010, R+1, 0x14);
+ memcpy(act_dat_buf+0x1010+0x14, S+1, 0x14);
+ printf("writing:signed_act.dat\n");
+ fp=fopen("signed_act.dat","wb");
+ fwrite(act_dat_buf, 0x1038,1,fp);
+ fclose(fp);
+ return 0;
+}
+
+static void set_ps2_iv(u8 iv[])
+{
+ memcpy(iv, ps2_iv, 0x10);
+}
+
+static inline u32 be32(u8 *p)
+{
+ u32 a;
+
+ a = p[0] << 24;
+ a |= p[1] << 16;
+ a |= p[2] << 8;
+ a |= p[3] << 0;
+
+ return a;
+}
+
+static inline u32 le32(u8 *p)
+{
+ u32 a;
+
+ a = p[3] << 24;
+ a |= p[2] << 16;
+ a |= p[1] << 8;
+ a |= p[0] << 0;
+
+ return a;
+}
+
+static inline u64 be64(u8 *p)
+{
+ u32 a, b;
+
+ a = be32(p);
+ b = be32(p + 4);
+
+ return ((u64)a<<32) | b;
+}
+
+
+void dump_meta(char mode[], FILE *in, char meta_file[], uint8_t *klicensee)
+{
+#define PS2_META_SEGMENT_START 1
+#define PS2_DATA_SEGMENT_START 2
+#define PS2_DEFAULT_SEGMENT_SIZE 0x4000
+#define PS2_META_ENTRY_SIZE 0x20
+ u8 ps2_key_cex_meta[] = { 0x38, 0x9D, 0xCB, 0xA5, 0x20, 0x3C, 0x81, 0x59, 0xEC, 0xF9, 0x4C, 0x93, 0x93, 0x16, 0x4C, 0xC9 };
+ u8 ps2_key_cex_data[] = { 0x10, 0x17, 0x82, 0x34, 0x63, 0xF4, 0x68, 0xC1, 0xAA, 0x41, 0xD7, 0x00, 0xB1, 0x40, 0xF2, 0x57 };
+ u8 ps2_key_cex_vmc[] = { 0x64, 0xE3, 0x0D, 0x19, 0xA1, 0x69, 0x41, 0xD6, 0x77, 0xE3, 0x2E, 0xEB, 0xE0, 0x7F, 0x45, 0xD2 };
+ FILE * meta_out;
+
+ u8 ps2_key_dex_meta[] = { 0x2B, 0x05, 0xF7, 0xC7, 0xAF, 0xD1, 0xB1, 0x69, 0xD6, 0x25, 0x86, 0x50, 0x3A, 0xEA, 0x97, 0x98 };
+u8 ps2_key_dex_data[] = { 0x74, 0xFF, 0x7E, 0x5D, 0x1D, 0x7B, 0x96, 0x94, 0x3B, 0xEF, 0xDC, 0xFA, 0x81, 0xFC, 0x20, 0x07 };
+u8 ps2_key_dex_vmc[] = { 0x30, 0x47, 0x9D, 0x4B, 0x80, 0xE8, 0x9E, 0x2B, 0x59, 0xE5, 0xC9, 0x14, 0x5E, 0x10, 0x64, 0xA9 };
+u8 ps2_data_key[0x10];
+ u8 ps2_meta_key[0x10];
+ u8 iv[0x10];
+
+ int segment_size;
+ s64 data_size;
+ int i;
+ u8 header[256];
+ u8 * data_buffer;
+ u8 * meta_buffer;
+ u32 read = 0;
+ int num_child_segments;
+
+ //open files
+ meta_out = fopen(meta_file, "wb");
+
+ //get file info
+ read = fread(header, 256, 1, in);
+ segment_size = be32(header + 0x84);
+ data_size = be64(header + 0x88);
+ num_child_segments = segment_size / PS2_META_ENTRY_SIZE;
+
+ printf("segment size: %x\ndata_size: %llx\n\n", segment_size, data_size);
+
+ //alloc buffers
+ data_buffer = (u8 *)malloc(segment_size*num_child_segments);
+ meta_buffer = (u8 *)malloc(segment_size);
+
+ //generate keys
+ if(strcmp(mode, "cex") == 0)
+ {
+ printf("cex\n");
+ set_ps2_iv(iv);
+ aescbc128_encrypt(ps2_key_cex_data, iv, klicensee, ps2_data_key, 0x10);
+ aescbc128_encrypt(ps2_key_cex_meta, iv, klicensee, ps2_meta_key, 0x10);
+ }else{
+ printf("dex\n");
+ set_ps2_iv(iv);
+ aescbc128_encrypt(ps2_key_dex_data, iv, klicensee, ps2_data_key, 0x10);
+ aescbc128_encrypt(ps2_key_dex_meta, iv, klicensee, ps2_meta_key, 0x10);
+ }
+
+
+ //decrypt iso
+ fseek(in, segment_size, SEEK_SET);
+
+ while(read = fread(meta_buffer, 1, segment_size, in))
+ {
+ //decrypt meta
+ aescbc128_decrypt(ps2_meta_key, iv, meta_buffer, meta_buffer, read);
+ fwrite(meta_buffer, read, 1, meta_out);
+ read = fread(data_buffer, 1, segment_size*num_child_segments, in);
+ }
+
+ //cleanup
+ free(data_buffer);
+ free(meta_buffer);
+
+ fclose(meta_out);
+ fseek(in, 0, SEEK_SET);
+}
+
+int sign_enc(FILE *fp)
+{
+ uint8_t *buf=(uint8_t *)malloc(0x200);
+ memset(buf,0,0x200);
+ fread(buf, 0x100,1,fp);
+ uint8_t R[0x15];
+ uint8_t S[0x15];
+ uint8_t digest[20];
+ sha1(buf, 0xd8, digest);
+ ecdsa_sign(digest,R,S);
+ fseek(fp, 0xD8, SEEK_SET);
+ fwrite(R+1, 0x14,1,fp);
+ fwrite(S+1,0x14,1,fp);
+ return 0;
+}
+
+static inline void wbe32(u8 *p, u32 v)
+{
+ p[0] = v >> 24;
+ p[1] = v >> 16;
+ p[2] = v >> 8;
+ p[3] = v;
+}
+
+static inline void wbe64(u8 *p, u64 v)
+{
+ wbe32(p + 4, v);
+ v >>= 32;
+ wbe32(p, v);
+}
+
+#include <openssl/sha.h>
+#include "pkg2zip_aes_x86.h"
+
+static void decrypt_debug_pkg_normal(uint8_t *pkg, uint64_t size, uint64_t offset, int file, uint64_t len)
+{
+ u8 key[0x40];
+ u8 bfr[0x1c];
+ u64 i;
+
+ memset(key, 0, sizeof key);
+ memcpy(key, pkg + 0x60, 8);
+ memcpy(key + 0x08, pkg + 0x60, 8);
+ memcpy(key + 0x10, pkg + 0x60 + 0x08, 8);
+ memcpy(key + 0x18, pkg + 0x60 + 0x08, 8);
+
+ sha1(key, sizeof key, bfr);
+
+ if(len>(10*1024*1024))
+ {
+ munmap(pkg, 10*1024*1024);
+ }
+ else
+ {
+ munmap(pkg, len);
+ }
+ if(len>(100*1024*1024))
+ {
+ pkg=(uint8_t *)mmap(0, 100*1024*1024, PROT_READ | PROT_WRITE, MAP_PRIVATE, file, 0);
+ }
+ else
+ {
+ pkg=(uint8_t *)mmap(0, len, PROT_READ | PROT_WRITE, MAP_PRIVATE, file, 0);
+ }
+
+ uint32_t last_round_size=len;
+ uint64_t count=offset;
+ lseek(file, 0, SEEK_SET);
+ for (i = offset; i < (size+offset); i++, count++) {
+ if (i != offset && (i % 16) == 0) {
+ wbe64(key + 0x38, be64(key + 0x38) + 1);
+ sha1(key, sizeof key, bfr);
+ }
+ if(i%(100*1024*1024)==0)
+ {
+ write(file, pkg, 100*1024*1024);
+ munmap(pkg, 100*1024*1024);
+ lseek(file, i, SEEK_SET);
+ if((size+offset-i)>(100*1024*1024))
+ {
+ pkg=(uint8_t *)mmap(0, 100*1024*1024, PROT_READ | PROT_WRITE, MAP_PRIVATE, file, i);
+ }
+ else
+ {
+ pkg=(uint8_t *)mmap(0, (size+offset-i), PROT_READ | PROT_WRITE, MAP_PRIVATE, file, i);
+ lseek(file, i, SEEK_SET);
+ last_round_size=(size+offset-i);
+ }
+ count=0;
+ }
+ pkg[count] ^= bfr[i & 0xf];
+ }
+ write(file, pkg, last_round_size);
+ munmap(pkg, last_round_size);
+}
+
+static void decrypt_debug_pkg_sse(uint8_t *pkg, uint64_t size, uint64_t offset, int file, uint64_t len)
+{
+ u8 key[0x40];
+ u8 bfr[0x1c];
+ u64 i;
+ u64 ret=0;
+ uint32_t last_round_size=len;
+
+ memset(key, 0, sizeof key);
+ memcpy(key, pkg + 0x60, 8);
+ memcpy(key + 0x08, pkg + 0x60, 8);
+ memcpy(key + 0x10, pkg + 0x60 + 0x08, 8);
+ memcpy(key + 0x18, pkg + 0x60 + 0x08, 8);
+
+ SHA1(key, sizeof key, bfr);
+
+ if(len>(10*1024*1024))
+ {
+ munmap(pkg, 10*1024*1024);
+ }
+ else
+ {
+ munmap(pkg, len);
+ }
+ if(len>(100*1024*1024))
+ {
+ pkg=(uint8_t *)mmap(0, 100*1024*1024, PROT_READ | PROT_WRITE, MAP_PRIVATE, file, 0);
+ }
+ else
+ {
+ pkg=(uint8_t *)mmap(0, len, PROT_READ | PROT_WRITE, MAP_PRIVATE, file, 0);
+ }
+
+ xor1_sse(pkg+offset,pkg+offset,bfr, 0x10);
+ lseek(file, 0, SEEK_SET);
+ uint64_t count=offset+0x10;
+ #pragma unroll
+ for (i = (0x10+offset); i < (size+offset); i+=0x10, count+=0x10) {
+
+ wbe64(key + 0x38, be64(key + 0x38) + 1);
+ SHA1(key, sizeof key, bfr);
+ if(i%(100*1024*1024)==0)
+ {
+ write(file, pkg, 100*1024*1024);
+ munmap(pkg, 100*1024*1024);
+ lseek(file, i, SEEK_SET);
+ if((size+offset-i)>(100*1024*1024))
+ {
+ pkg=(uint8_t *)mmap(0, 100*1024*1024, PROT_READ | PROT_WRITE, MAP_PRIVATE, file, i);
+ }
+ else
+ {
+ pkg=(uint8_t *)mmap(0, (size+offset-i), PROT_READ | PROT_WRITE, MAP_PRIVATE, file, i);
+ lseek(file, i, SEEK_SET);
+ last_round_size=(size+offset-i);
+ }
+ count=0;
+ }
+ xor1_sse(pkg+count,pkg+count,bfr, 0x10);
+ }
+
+ write(file, pkg, last_round_size);
+ munmap(pkg, last_round_size);
+}
+
+static void decrypt_debug_pkg(uint8_t *pkg, uint64_t size, uint64_t offset_data, int file, uint64_t len)
+{
+ if(aes128_supported_x86())
+ {
+ decrypt_debug_pkg_sse(pkg,size,offset_data, file, len);
+ }
+ else
+ {
+ decrypt_debug_pkg_normal(pkg,size,offset_data, file, len);
+ }
+}
+
+int decrypt_retail_pkg_data(uint8_t *buf, uint64_t size, uint8_t *data_riv, uint8_t *gpkg_key)
+{
+ aes128ctr(gpkg_key, data_riv, buf, size, buf);
+ return 0;
+}
+
+static void check_ps2_pkg_patch(uint8_t *pkg, uint64_t offset, int fd)
+{
+ u64 i;
+ u64 n_files;
+ u32 fname_len;
+ u32 fname_off;
+ u64 file_offset;
+ u32 flags;
+ char fname[256];
+ u8 *tmp;
+ u8 tmp_buf[0x100];
+
+ uint8_t digest[20];
+ uint8_t R[0x15];
+ uint8_t S[0x15];
+
+ u8 magic_ps2[4]={'P','S','2',0x00};
+ u8 magic_edat[4]={'N','P','D',0x00};
+
+ n_files = be32(pkg + 0x14);
+
+ for (i = 0; i < n_files; i++) {
+ tmp = pkg + offset + i*0x20;
+
+ fname_off = be32(tmp) + offset;
+ fname_len = be32(tmp + 0x04);
+ file_offset = be64(tmp + 0x08) + offset;
+ uint64_t size = be64(tmp + 0x10);
+ flags = be32(tmp + 0x18);
+ if (fname_len >= sizeof fname)
+ printf("filename too long: %s\n", pkg + fname_off);
+
+ memset(fname, 0, sizeof fname);
+ memset(tmp_buf, 0, sizeof tmp_buf);
+ strncpy(fname, (char *)(pkg + fname_off), fname_len);
+ flags &= 0xff;
+ printf("%s\n", fname);
+
+ char *last_slash=strrchr(fname, '/');
+ if(!last_slash) //we are in root of pkg
+ {
+ continue;
+ }
+ if((strstr(last_slash, ".edat")) || (strstr(last_slash, ".EDAT")) || (strstr(last_slash, "CONFIG")) || (strstr(last_slash, "ISO.BIN.ENC")))
+ {
+ if(flags != 4) //it is not a directory
+ {
+ printf("found %s..Resigning\n", last_slash);
+ //sign_enc_buf(pkg+file_offset);
+ lseek(fd,file_offset+0x00, SEEK_SET);
+ read(fd, tmp_buf, 0x100);
+ if((memcmp(tmp_buf, magic_ps2, 4)==0) || (memcmp(tmp_buf, magic_edat,4)==0)) //it is indeed a ps2 file or edat
+ {
+ sha1(tmp_buf, 0xd8, digest);
+ ecdsa_sign(digest, R, S);
+ lseek(fd,file_offset+0xd8, SEEK_SET);
+ write(fd, R+1, 0x14);
+ lseek(fd,file_offset+0xd8+0x14, SEEK_SET);
+ write(fd, S+1, 0x14);
+ }
+ }
+ }
+ }
+}
+
+typedef struct __TOC_HEADER {
+ uint32_t fname_offset;
+ uint32_t name_size;
+ uint64_t file_off;
+ uint64_t file_size;
+ uint8_t psp_key_type;
+ uint8_t shit_stuff[7];
+} TOC_HEADER;
+
+int parse_psp_pkg(uint8_t *pkg, uint32_t toc_len, uint8_t *iv_const, uint32_t data_size, int file_out, uint64_t offset_data)
+{
+ TOC_HEADER *header=(TOC_HEADER *)malloc(2*1024*1024);
+ uint8_t pkg_key[0x10]={0x2E,0x7B,0x71,0xD7,0xC9,0xC9,0xA1,0x4E,0xA3,0x22,0x1F,0x18,0x88,0x28,0xB8,0xF8};
+ uint8_t pkg_key_psp[0x10]={0x07,0xF2,0xC6,0x82,0x90,0xB5,0x0D,0x2C,0x33,0x81,0x8D,0x70,0x9B,0x60,0xE6,0x2B};
+
+ aes128_key ps3_key;
+ aes128_init(&ps3_key, pkg_key);
+
+ memcpy(header, pkg, toc_len);
+ int i=0;
+ int number_files=toc_len/0x20;
+ uint8_t main_key[0x10];
+
+ uint32_t len_dec_name=0;
+ uint8_t second_last;
+ uint8_t *tmp_buf=(uint8_t *)malloc(100*1024*1024);
+ uint8_t name[4096]={0};
+
+ for(i=0;i<number_files;i++)
+ {
+ header[i].fname_offset=swap_uint32(header[i].fname_offset);
+ header[i].name_size=swap_uint32(header[i].name_size);
+ header[i].file_off=swap_uint64(header[i].file_off);
+ header[i].file_size=swap_uint64(header[i].file_size);
+
+ if(header[i].psp_key_type==0x90)
+ {
+ memcpy(main_key, pkg_key_psp, 0x10);
+ }
+ else
+ {
+ memcpy(main_key, pkg_key, 0x10);
+ }
+
+ aes128_key key;
+ aes128_init(&key, main_key);
+
+ len_dec_name=header[i].name_size&0xf0;
+ if(header[i].name_size&0xf)
+ {
+ len_dec_name+=0x10;
+ }
+
+ printf("len_dec_name=%x\n", len_dec_name);
+ printf("header[i].fname_offset=%x\n", header[i].fname_offset);
+ printf("header[i].file_off=%x\n", header[i].file_off);
+ printf("header[i].file_size=%x\n", header[i].file_size);
+ printf("number_files=%x\n", number_files);
+
+ int loop=0;
+ printf("key: ");
+
+ for (loop = 0; loop < 0x10; loop++)
+ {
+ printf("%02X", main_key[loop]);
+ }
+ printf("\n");
+
+ loop=0;
+ printf("iv: ");
+
+ for (loop = 0; loop < 0x10; loop++)
+ {
+ printf("%02X", iv_const[loop]);
+ }
+ printf("\n");
+
+ memcpy(name, pkg+header[i].fname_offset, len_dec_name);
+ aes128_ctr_xor(&key, iv_const, (header[i].fname_offset)/16, name, len_dec_name);
+ lseek(file_out, header[i].fname_offset+offset_data, SEEK_SET);
+ write(file_out, name, len_dec_name);
+
+ if(header[i].file_size)
+ {
+ uint64_t loop=0;
+ for(loop=0;loop<header[i].file_size;loop+=100*1024*1024)
+ {
+ if(header[i].file_size-loop<100*1024*1024)
+ {
+ lseek(file_out, header[i].file_off+offset_data+loop, SEEK_SET);
+ read(file_out, tmp_buf, header[i].file_size-loop);
+ aes128_ctr_xor(&key, iv_const, (header[i].file_off+loop)/16, tmp_buf, header[i].file_size-loop);
+ lseek(file_out, header[i].file_off+offset_data+loop, SEEK_SET);
+ write(file_out, tmp_buf, header[i].file_size-loop);
+ }
+ else
+ {
+ lseek(file_out, header[i].file_off+offset_data+loop, SEEK_SET);
+ read(file_out, tmp_buf, 100*1024*1024);
+ aes128_ctr_xor(&key, iv_const, (header[i].file_off+loop)/16, tmp_buf, 100*1024*1024);
+ lseek(file_out, header[i].file_off+offset_data+loop, SEEK_SET);
+ write(file_out, tmp_buf, 100*1024*1024);
+ }
+ }
+ }
+ }
+ free(tmp_buf);
+ return 0;
+}
+
+int parse_ps3_psp_pkg(uint8_t *pkg, uint32_t toc_len, uint8_t *iv_const)
+{
+ TOC_HEADER *header=(TOC_HEADER *)malloc(2*1024*1024);
+ uint8_t pkg_key[0x10]={0x2E,0x7B,0x71,0xD7,0xC9,0xC9,0xA1,0x4E,0xA3,0x22,0x1F,0x18,0x88,0x28,0xB8,0xF8};
+ uint8_t pkg_key_psp[0x10]={0x07,0xF2,0xC6,0x82,0x90,0xB5,0x0D,0x2C,0x33,0x81,0x8D,0x70,0x9B,0x60,0xE6,0x2B};
+
+ aes128_key ps3_key;
+ aes128_init(&ps3_key, pkg_key);
+
+ memcpy(header, pkg, toc_len);
+ int i=0;
+ int number_files=toc_len/0x20;
+ uint8_t main_key[0x10];
+
+ uint32_t len_dec_name=0;
+ uint8_t second_last;
+ for(i;i<number_files;i++)
+ {
+ header[i].fname_offset=swap_uint32(header[i].fname_offset);
+ header[i].name_size=swap_uint32(header[i].name_size);
+ header[i].file_off=swap_uint64(header[i].file_off);
+ header[i].file_size=swap_uint64(header[i].file_size);
+
+ if(header[i].psp_key_type==0x90)
+ {
+ memcpy(main_key, pkg_key_psp, 0x10);
+ }
+ else
+ {
+ memcpy(main_key, pkg_key, 0x10);
+ }
+
+ aes128_key key;
+ aes128_init(&key, main_key);
+
+ if(header[i].name_size>0x10)
+ {
+ len_dec_name=0x20;
+ }
+ else if(header[i].name_size>0x20)
+ {
+ len_dec_name=0x30;
+ }
+ else
+ {
+ len_dec_name=0x10;
+ }
+ printf("len_dec_name=%x\n", len_dec_name);
+ printf("header[i].fname_offset=%x\n", header[i].fname_offset);
+ printf("header[i].file_off=%x\n", header[i].file_off);
+ printf("header[i].file_size=%x\n", header[i].file_size);
+ printf("number_files=%x\n", number_files);
+
+ int loop=0;
+ printf("key: ");
+
+ for (loop = 0; loop < 0x10; loop++)
+ {
+ printf("%02X", main_key[loop]);
+ }
+ printf("\n");
+
+ loop=0;
+ printf("iv: ");
+
+ for (loop = 0; loop < 0x10; loop++)
+ {
+ printf("%02X", iv_const[loop]);
+ }
+ printf("\n");
+
+ // aes128ctrxor(main_key, iv_const, pkg+header[i].fname_offset, len_dec_name, pkg+header[i].fname_offset,header[i].fname_offset-toc_len);
+ aes128_ctr_xor(&key, iv_const, ((header[i].fname_offset)-toc_len)/16, pkg+header[i].fname_offset, len_dec_name);
+ aes128_ctr_xor(&key, iv_const, ((header[i].file_off)-toc_len)/16, pkg+header[i].file_off, header[i].file_size);
+
+ // aes128ctrxor(main_key, iv_const, pkg+header[i].file_off, header[i].file_size, pkg+header[i].file_off,header[i].file_off-toc_len);
+ }
+ return 0;
+}
+
+int main(int argc, char *argv[])
+{
+ printf("----------------PS3XPLOIT RESIGNER v3----------------\nHAN v3 tools brought you by W, escortd3w, bguerville, habib\nSpecial thanks to Joonie for testing this tool\n-----------------------------------------------------\n");
+
+ if(argc<2)
+ {
+ goto done;
+ }
+
+if((strstr(argv[1], ".rap")) || (strstr(argv[1], ".RAP")))
+ {
+ if(read_act_dat_and_make_rif(argv[1])==0)
+ {
+ sign_act_dat();
+ printf("\nits done!\npress enter\n");
+ }
+ else
+ {
+ printf("\nverify your files!");
+ }
+ getchar();
+ getchar();
+ return 0;
+ }
+ else if((strstr(argv[1], ".EDAT")) || (strstr(argv[1], ".edat")))
+ {
+ char *slash2 = strrchr (argv[1], '\\');
+ if (slash2 != NULL)
+ {
+ *slash2 = '\0';
+ argv[1]=slash2+1;
+ }
+ FILE *fp=fopen(argv[1], "rb+");
+ if(!fp)
+ {
+ printf("edat unreadable!\n");
+ }
+
+ uint32_t license;
+ char *content_id_edat=(char *)malloc(0x100);
+ memset(content_id_edat,0,0x100);
+ fread(content_id_edat, 0x34, 1,fp);
+ memcpy(&license, content_id_edat+8, 4);
+ license=swap_uint32(license);
+ content_id_edat+=0x10;
+ uint8_t rifkey[0x10];
+
+/*OLD METHOD!!!!!*/
+/* if((license==2) || (license==3))
+ {
+ read_rif_key(content_id_edat, rifkey);
+ }
+ uint8_t meta_sig_hash_output[20];
+ uint8_t header_sig_hash_output[20];
+ unsigned char devklic_edat[16] = {0x52,0xC0,0xB5,0xCA,0x76,0xD6,0x13,0x4B,0xB4,0x5F,0xC6,0x6C,0xA6,0x37,0xF2,0xC1};
+
+ FILE *devklic_explicit=fopen("devklic", "rb");
+ if(devklic_explicit)
+ {
+ printf("using explicit devklic\n");
+ fread(devklic_edat, 16, 1, devklic_explicit);
+ fclose(devklic_explicit);
+ }
+
+ if(extract_data_and_sign(fp, devklic_edat, rifkey, 0))
+ {
+ getchar();
+ return -1;
+ }
+*/
+/*END*/
+/* NEW METHOD!!!!!!!!*/
+ ecdsa_set_curve();
+ ecdsa_set_pub();
+ ecdsa_set_priv();
+ fseek(fp,0,SEEK_SET);
+ sign_enc(fp);
+/*END*/
+ fclose(fp);
+ printf("edat resigned!\n");
+ fp=fopen("ISO.BIN.ENC", "rb+");
+ if(fp)
+ {
+ // dump_meta((char *)"cex", fp, (char *)"ISO.BIN.ENC_meta_out", rifkey);
+ sign_enc(fp);
+ printf("enc resigned!\n");
+ fclose(fp);
+ fp=fopen("CONFIG", "rb+");
+ if(fp)
+ {
+ sign_enc(fp);
+ printf("config resigned!\n");
+ fclose(fp);
+ }
+ }
+ getchar();
+ getchar();
+ return 0;
+ }
+ else if((strstr(argv[1], ".pkg")) || (strstr(argv[1], ".PKG")))
+ {
+ ecdsa_set_curve();
+ ecdsa_set_pub();
+ ecdsa_set_priv();
+ struct stat stat1;
+ if(stat(argv[1], &stat1)!=0)
+ {
+ printf("cant open file!\n");
+ getchar();
+ return -1;
+ }
+ uint64_t len=stat1.st_size;
+ printf("size:%016llx\n", len);
+
+ int fd=open(argv[1], O_RDONLY);
+ uint8_t *buf2=NULL;
+ char out_path[4096];
+ strcpy(out_path, argv[1]);
+ strcat(out_path, "_signed.pkg");
+ int fd_out=open(out_path, O_RDWR|O_CREAT, 0600);
+ lseek(fd_out, 0, SEEK_SET);
+ printf("making backup\n");
+ uint64_t bkp=0;
+ for(bkp;bkp<len;bkp+=100*1024*1024)
+ {
+ if(len-bkp<100*1024*1024)
+ {
+ buf2=(uint8_t *)mmap(0, len-bkp, PROT_READ, MAP_SHARED, fd, bkp);
+ write(fd_out, buf2, len-bkp);
+ munmap(buf2, len-bkp);
+ }
+ else
+ {
+ buf2=(uint8_t *)mmap(0, 100*1024*1024, PROT_READ, MAP_SHARED, fd, bkp);
+ printf("bkp:%016llx\n", bkp);
+ lseek(fd_out, bkp, SEEK_SET);
+ write(fd_out, buf2, 100*1024*1024);
+ munmap(buf2, 100*1024*1024);
+ }
+ }
+
+ close(fd);
+ uint8_t *buf=NULL;
+ if(len>(10*1024*1024))
+ {
+ buf=(uint8_t *)mmap(0, 10*1024*1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd_out, 0);
+ }
+ else
+ {
+ buf=(uint8_t *)mmap(0, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd_out, 0);
+ }
+
+ if(!buf)
+ {
+ printf("not enough free memory!\n");
+ return -1;
+ }
+ uint64_t data_size=*(uint64_t *)(buf+0x28);
+ uint8_t iv[0x10];
+ uint64_t offset_data=*(uint64_t *)(buf+0x20);
+ offset_data=swap_uint64(offset_data);
+ uint32_t pkg_info_offset=*(uint32_t *)(buf+0x8);
+ pkg_info_offset=swap_uint32(pkg_info_offset);
+ uint32_t header_size=*(uint32_t *)(buf+0x10);
+ header_size=swap_uint32(header_size);
+ uint32_t toc_size=(swap_uint32(*(uint32_t *)(buf+0x14)))*0x20;
+
+ uint32_t pkg_type=*(uint32_t *)(buf+pkg_info_offset+0x14);
+ pkg_type=swap_uint32(pkg_type);
+
+ memcpy(iv, buf+0x70, 0x10);
+ uint8_t iv_bkp[0x10];
+ memcpy(iv_bkp, iv, 0x10);
+ data_size=swap_uint64(data_size);
+ uint8_t pkg_key[0x10]={0x2E,0x7B,0x71,0xD7,0xC9,0xC9,0xA1,0x4E,0xA3,0x22,0x1F,0x18,0x88,0x28,0xB8,0xF8};
+ uint8_t pkg_key_psp[0x10]={0x07,0xF2,0xC6,0x82,0x90,0xB5,0x0D,0x2C,0x33,0x81,0x8D,0x70,0x9B,0x60,0xE6,0x2B};
+ if(*(uint8_t *)&buf[4]!=0x80)
+ {
+ *(uint8_t *)&buf[4]=0x80;
+ uint8_t retail_flag=0x80;
+
+
+ if((pkg_type==0xf) || (pkg_type==0x6) || (pkg_type==0x7)) //0xf==minis, 0x6==ps1, 0x7==psp, 0x14==remastered
+ {
+ printf("PKG type PSP/PSX detected\n");
+ *(uint8_t *)&buf[7]=2;
+ }
+ printf("decrypting debug pkg\n");
+ decrypt_debug_pkg(buf, data_size, offset_data, fd_out, len);
+
+ if(len>(10*1024*1024))
+ {
+ buf=(uint8_t *)mmap(0, 10*1024*1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd_out, 0);
+ }
+ else
+ {
+ buf=(uint8_t *)mmap(0, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd_out, 0);
+ }
+
+ printf("encrypting retail pkg\n");
+ check_ps2_pkg_patch(buf, offset_data, fd_out);
+ if(*(uint8_t *)&buf[7]==2)
+ {
+ memcpy(iv, iv_bkp, 0x10);
+ parse_psp_pkg(buf+offset_data, toc_size, iv, data_size, fd_out, offset_data);
+
+ memcpy(iv, iv_bkp, 0x10);
+ decrypt_retail_pkg_data(buf+offset_data, toc_size, iv, pkg_key_psp);
+ memcpy(iv, iv_bkp, 0x10);
+ }
+ else
+ {
+ memcpy(iv, iv_bkp, 0x10);
+ parse_psp_pkg(buf+offset_data, toc_size, iv, data_size, fd_out, offset_data);
+
+ memcpy(iv, iv_bkp, 0x10);
+ decrypt_retail_pkg_data(buf+offset_data, toc_size, iv, pkg_key);
+ }
+ cmac_hash_forge(pkg_key, 0x10, buf, 0x80, buf+0x80);
+ }
+ else
+ {
+ printf("decrypting retail pkg\n");
+ if(*(uint8_t *)&buf[7]==2)
+ {
+ printf("type psp detected\n");
+ decrypt_retail_pkg_data(buf+offset_data, toc_size, iv, pkg_key_psp);
+ memcpy(iv, iv_bkp, 0x10);
+ parse_psp_pkg(buf+offset_data, toc_size, iv, data_size, fd_out, offset_data);
+
+ }
+ else
+ {
+ memcpy(iv, iv_bkp, 0x10);
+ decrypt_retail_pkg_data(buf+offset_data, toc_size, iv, pkg_key);
+ memcpy(iv, iv_bkp, 0x10);
+ parse_psp_pkg(buf+offset_data, toc_size, iv, data_size, fd_out, offset_data);
+
+ memcpy(iv, iv_bkp, 0x10);
+ }
+ printf("encrypting retail pkg\n");
+ check_ps2_pkg_patch(buf, offset_data, fd_out);
+
+ if(*(uint8_t *)&buf[7]==2)
+ {
+ parse_psp_pkg(buf+offset_data, toc_size, iv, data_size, fd_out, offset_data);
+ memcpy(iv, iv_bkp,0x10);
+ decrypt_retail_pkg_data(buf+offset_data, toc_size, iv, pkg_key_psp);
+ }
+ else
+ {
+ memcpy(iv, iv_bkp,0x10);
+ parse_psp_pkg(buf+offset_data, toc_size, iv, data_size, fd_out, offset_data);
+
+ memcpy(iv, iv_bkp,0x10);
+ decrypt_retail_pkg_data(buf+offset_data, toc_size, iv, pkg_key);
+ }
+ cmac_hash_forge(pkg_key, 0x10, buf, 0x80, buf+0x80);
+ }
+
+ uint8_t digest[20];
+ uint8_t R[0x15];
+ uint8_t S[0x15];
+
+ cmac_hash_forge(pkg_key, 0x10, buf+pkg_info_offset, header_size-0x40, buf+pkg_info_offset+header_size-0x40);
+
+ if(len>(10*1024*1024))
+ {
+ munmap(buf, 10*1024*1024);
+ }
+ else
+ {
+ munmap(buf, len);
+ }
+
+ SHA_CTX ctx;
+
+ SHA1_Init( &ctx );
+ uint64_t sha1_loop=0;
+ for(sha1_loop;sha1_loop<len-0x20;sha1_loop+=100*1024*1024)
+ {
+ if(len-sha1_loop-0x20<100*1024*1024)
+ {
+ buf=(uint8_t *)mmap(0, len-sha1_loop, PROT_READ | PROT_WRITE, MAP_SHARED, fd_out, sha1_loop);
+ SHA1_Update( &ctx, buf, len-sha1_loop-0x20 );
+ SHA1_Final(buf+len-sha1_loop-0x20, &ctx);
+ munmap(buf, len-sha1_loop);
+ }
+ else
+ {
+ buf=(uint8_t *)mmap(0, 100*1024*1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd_out, sha1_loop);
+ SHA1_Update(&ctx, buf, 100*1024*1024);
+ munmap(buf, 100*1024*1024);
+ }
+ }
+
+ close(fd_out);
+ chmod(out_path, 0777);
+ printf("pkg signed!\n");
+ getchar();
+ getchar();
+ return 0;
+ }
+ else if(strstr(argv[1], ".ENC"))
+ {
+ ecdsa_set_curve();
+ ecdsa_set_pub();
+ ecdsa_set_priv();
+ FILE *fp=fopen(argv[1], "rb+");
+ sign_enc(fp);
+ printf("enc resigned!\n");
+ fclose(fp);
+ fp=fopen("CONFIG", "rb+");
+ if(fp)
+ {
+ sign_enc(fp);
+ printf("config resigned!\n");
+ fclose(fp);
+ }
+ getchar();
+ getchar();
+ }
+
+done:
+ printf("no valid option or no valid file provided!\n");
+ getchar();
+ getchar();
+ return -1;
+}
\ No newline at end of file |