diff --git a/Source/Core/DiscIO/Src/VolumeWiiCrypted.cpp b/Source/Core/DiscIO/Src/VolumeWiiCrypted.cpp
index fc7d57e565..935f101021 100644
--- a/Source/Core/DiscIO/Src/VolumeWiiCrypted.cpp
+++ b/Source/Core/DiscIO/Src/VolumeWiiCrypted.cpp
@@ -98,6 +98,11 @@ bool CVolumeWiiCrypted::Read(u64 _ReadOffset, u64 _Length, u8* _pBuffer) const
return(true);
}
+bool CVolumeWiiCrypted::GetTitleID(u8* _pBuffer) const
+{
+ return RAWRead((u64)0x0F8001DC, 8, _pBuffer);
+}
+
std::string CVolumeWiiCrypted::GetUniqueID() const
{
if (m_pReader == NULL)
diff --git a/Source/Core/DiscIO/Src/VolumeWiiCrypted.h b/Source/Core/DiscIO/Src/VolumeWiiCrypted.h
index af17eb0203..e6a93e855a 100644
--- a/Source/Core/DiscIO/Src/VolumeWiiCrypted.h
+++ b/Source/Core/DiscIO/Src/VolumeWiiCrypted.h
@@ -33,6 +33,7 @@ public:
~CVolumeWiiCrypted();
bool Read(u64 _Offset, u64 _Length, u8* _pBuffer) const;
bool RAWRead(u64 _Offset, u64 _Length, u8* _pBuffer) const;
+ bool GetTitleID(u8* _pBuffer) const;
std::string GetUniqueID() const;
std::string GetMakerID() const;
std::string GetName() const;
diff --git a/Source/Core/DolphinWX/DolphinWX.vcproj b/Source/Core/DolphinWX/DolphinWX.vcproj
index 0af4eef3e1..d5543355db 100644
--- a/Source/Core/DolphinWX/DolphinWX.vcproj
+++ b/Source/Core/DolphinWX/DolphinWX.vcproj
@@ -1542,6 +1542,38 @@
>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/Source/Core/DolphinWX/Src/FrameTools.cpp b/Source/Core/DolphinWX/Src/FrameTools.cpp
index f2f332e174..82eaec7f53 100644
--- a/Source/Core/DolphinWX/Src/FrameTools.cpp
+++ b/Source/Core/DolphinWX/Src/FrameTools.cpp
@@ -49,7 +49,6 @@ Core::GetWindowHandle().
#include "ConfigMain.h"
#include "PluginManager.h"
#include "MemcardManager.h"
-#include "MemoryCards/WiiSaveCrypted.h"
#include "CheatsWindow.h"
#include "LuaWindow.h"
#include "AboutDolphin.h"
@@ -814,8 +813,8 @@ void CFrame::OnImportSave(wxCommandEvent& WXUNUSED (event))
if (!path.IsEmpty())
{
- CWiiSaveCrypted saveFile(path.ToUTF8().data());
- saveFile.Extract();
+ CWiiSaveCrypted* saveFile = new CWiiSaveCrypted(path.ToUTF8().data());
+ delete saveFile;
}
}
diff --git a/Source/Core/DolphinWX/Src/GameListCtrl.cpp b/Source/Core/DolphinWX/Src/GameListCtrl.cpp
index 581657445a..c9359ecdec 100644
--- a/Source/Core/DolphinWX/Src/GameListCtrl.cpp
+++ b/Source/Core/DolphinWX/Src/GameListCtrl.cpp
@@ -106,6 +106,7 @@ BEGIN_EVENT_TABLE(CGameListCtrl, wxListCtrl)
EVT_MENU(IDM_PROPERTIES, CGameListCtrl::OnProperties)
EVT_MENU(IDM_OPENCONTAININGFOLDER, CGameListCtrl::OnOpenContainingFolder)
EVT_MENU(IDM_OPENSAVEFOLDER, CGameListCtrl::OnOpenSaveFolder)
+ EVT_MENU(IDM_EXPORTSAVE, CGameListCtrl::OnExportSave)
EVT_MENU(IDM_SETDEFAULTGCM, CGameListCtrl::OnSetDefaultGCM)
EVT_MENU(IDM_COMPRESSGCM, CGameListCtrl::OnCompressGCM)
EVT_MENU(IDM_MULTICOMPRESSGCM, CGameListCtrl::OnMultiCompressGCM)
@@ -803,8 +804,10 @@ void CGameListCtrl::OnRightClick(wxMouseEvent& event)
popupMenu->AppendSeparator();
if (selected_iso->GetPlatform() != GameListItem::GAMECUBE_DISC)
+ {
popupMenu->Append(IDM_OPENSAVEFOLDER, _("Open Wii &save folder"));
-
+ popupMenu->Append(IDM_EXPORTSAVE, _("Export Wii save (Experimental)"));
+ }
popupMenu->Append(IDM_OPENCONTAININGFOLDER, _("Open &containing folder"));
popupMenu->AppendCheckItem(IDM_SETDEFAULTGCM, _("Set as &default ISO"));
@@ -883,6 +886,24 @@ void CGameListCtrl::OnOpenSaveFolder(wxCommandEvent& WXUNUSED (event))
WxUtils::Explore(iso->GetWiiFSPath().c_str());
}
+void CGameListCtrl::OnExportSave(wxCommandEvent& WXUNUSED (event))
+{
+ const GameListItem *iso = GetSelectedISO();
+ if (!iso)
+ return;
+ u64 title;
+ DiscIO::IVolume *Iso = DiscIO::CreateVolumeFromFilename(iso->GetFileName());
+ if (Iso)
+ {
+ if (Iso->GetTitleID((u8*)&title))
+ {
+ title = Common::swap64(title);
+ CWiiSaveCrypted* exportSave = new CWiiSaveCrypted("", title);
+ delete exportSave;
+ }
+ delete Iso;
+ }
+}
// =======================================================
// Save this file as the default file
diff --git a/Source/Core/DolphinWX/Src/GameListCtrl.h b/Source/Core/DolphinWX/Src/GameListCtrl.h
index 4f69ede198..f969c5a683 100644
--- a/Source/Core/DolphinWX/Src/GameListCtrl.h
+++ b/Source/Core/DolphinWX/Src/GameListCtrl.h
@@ -24,7 +24,7 @@
#include
#include "ISOFile.h"
-
+#include "MemoryCards/WiiSaveCrypted.h"
class wxEmuStateTip : public wxTipWindow
{
@@ -98,6 +98,7 @@ private:
void OnProperties(wxCommandEvent& event);
void OnOpenContainingFolder(wxCommandEvent& event);
void OnOpenSaveFolder(wxCommandEvent& event);
+ void OnExportSave(wxCommandEvent& event);
void OnSetDefaultGCM(wxCommandEvent& event);
void OnDeleteGCM(wxCommandEvent& event);
void OnCompressGCM(wxCommandEvent& event);
diff --git a/Source/Core/DolphinWX/Src/Globals.h b/Source/Core/DolphinWX/Src/Globals.h
index 95322c6b2a..5be7bfb6c1 100644
--- a/Source/Core/DolphinWX/Src/Globals.h
+++ b/Source/Core/DolphinWX/Src/Globals.h
@@ -224,6 +224,7 @@ enum
IDM_NOTIFYMAPLOADED,
IDM_OPENCONTAININGFOLDER,
IDM_OPENSAVEFOLDER,
+ IDM_EXPORTSAVE,
IDM_IMPORTSAVE,
IDM_SETDEFAULTGCM,
IDM_DELETEGCM,
diff --git a/Source/Core/DolphinWX/Src/ISOFile.cpp b/Source/Core/DolphinWX/Src/ISOFile.cpp
index a27142a4e6..178d150433 100644
--- a/Source/Core/DolphinWX/Src/ISOFile.cpp
+++ b/Source/Core/DolphinWX/Src/ISOFile.cpp
@@ -24,7 +24,6 @@
#include "ISOFile.h"
#include "StringUtil.h"
-#include "VolumeCreator.h"
#include "Filesystem.h"
#include "BannerLoader.h"
#include "FileSearch.h"
@@ -216,6 +215,7 @@ const std::string GameListItem::GetWiiFSPath() const
{
DiscIO::IVolume *Iso = DiscIO::CreateVolumeFromFilename(m_FileName);
+ std::string ret("NULL");
if (Iso != NULL)
{
if (DiscIO::IsVolumeWiiDisc(Iso) || DiscIO::IsVolumeWadFile(Iso))
@@ -223,11 +223,7 @@ const std::string GameListItem::GetWiiFSPath() const
char Path[250];
u64 Title;
- if (DiscIO::IsVolumeWiiDisc(Iso))
- Iso->RAWRead((u64)0x0F8001DC, 8, (u8*)&Title);
- else
- Iso->GetTitleID((u8*)&Title);
-
+ Iso->GetTitleID((u8*)&Title);
Title = Common::swap64(Title);
sprintf(Path, FULL_WII_USER_DIR "title/%08x/%08x/data/", (u32)(Title>>32), (u32)Title);
@@ -235,10 +231,11 @@ const std::string GameListItem::GetWiiFSPath() const
if (!File::Exists(Path))
File::CreateFullPath(Path);
- return std::string(wxGetCwd().mb_str()) + std::string(Path).substr(strlen(ROOT_DIR));
+ ret = std::string(wxGetCwd().mb_str()) + std::string(Path).substr(strlen(ROOT_DIR));
}
+ delete Iso;
}
- return "NULL";
+ return ret;
}
diff --git a/Source/Core/DolphinWX/Src/ISOFile.h b/Source/Core/DolphinWX/Src/ISOFile.h
index bf8655d049..439caba66d 100644
--- a/Source/Core/DolphinWX/Src/ISOFile.h
+++ b/Source/Core/DolphinWX/Src/ISOFile.h
@@ -19,6 +19,7 @@
#define __ISOFILE_H_
#include "Volume.h"
+#include "VolumeCreator.h"
class PointerWrap;
class GameListItem
diff --git a/Source/Core/DolphinWX/Src/MemcardManager.cpp b/Source/Core/DolphinWX/Src/MemcardManager.cpp
index 7a2a31416d..dde45dba97 100644
--- a/Source/Core/DolphinWX/Src/MemcardManager.cpp
+++ b/Source/Core/DolphinWX/Src/MemcardManager.cpp
@@ -757,9 +757,10 @@ bool CMemcardManager::ReloadMemcard(const char *fileName, int card)
if (!memoryCard[card]->DEntry_Comment1(j, title)) title[0]=0;
if (!memoryCard[card]->DEntry_Comment2(j, comment)) comment[0]=0;
+ bool ascii = memoryCard[card]->IsAsciiEncoding();
wxCSConv SJISConv(wxT("SHIFT_JIS"));
- wxTitle = wxString(title, SJISConv);
- wxComment = wxString(comment, SJISConv);
+ wxTitle = wxString(title, ascii ? *wxConvCurrent : SJISConv);
+ wxComment = wxString(comment, ascii ? *wxConvCurrent : SJISConv);
m_MemcardList[card]->SetItem(index, COLUMN_TITLE, wxTitle);
m_MemcardList[card]->SetItem(index, COLUMN_COMMENT, wxComment);
diff --git a/Source/Core/DolphinWX/Src/MemoryCards/Crypto/bn.cpp b/Source/Core/DolphinWX/Src/MemoryCards/Crypto/bn.cpp
new file mode 100644
index 0000000000..78e6dc5eae
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/MemoryCards/Crypto/bn.cpp
@@ -0,0 +1,123 @@
+// Copyright 2007,2008 Segher Boessenkool
+// Licensed under the terms of the GNU GPL, version 2
+// http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
+
+#include
+#include
+#include "Common.h"
+#include "tools.h"
+
+/*static 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);
+}
+
+static 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;
+}
+
+void bn_sub_modulus(u8 *a, u8 *N, u32 n)
+{
+ u32 i;
+ u32 dig;
+ u8 c;
+
+ c = 0;
+ for (i = n - 1; i < n; i--) {
+ dig = N[i] + c;
+ c = (a[i] < dig);
+ a[i] -= dig;
+ }
+}
+
+void bn_add(u8 *d, u8 *a, u8 *b, u8 *N, 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 >= 0x100);
+ d[i] = dig;
+ }
+
+ if (c)
+ bn_sub_modulus(d, N, n);
+
+ if (bn_compare(d, N, n) >= 0)
+ bn_sub_modulus(d, N, n);
+}
+
+void bn_mul(u8 *d, u8 *a, u8 *b, u8 *N, u32 n)
+{
+ u32 i;
+ u8 mask;
+
+ bn_zero(d, n);
+
+ for (i = 0; i < n; i++)
+ for (mask = 0x80; mask != 0; mask >>= 1) {
+ bn_add(d, d, d, N, n);
+ if ((a[i] & mask) != 0)
+ bn_add(d, d, b, N, n);
+ }
+}
+
+void bn_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;
+ for (i = 0; i < en; i++)
+ for (mask = 0x80; mask != 0; mask >>= 1) {
+ bn_mul(t, d, d, N, n);
+ if ((e[i] & mask) != 0)
+ bn_mul(d, t, a, N, n);
+ else
+ bn_copy(d, t, n);
+ }
+}
+
+// only for prime N -- stupid but lazy, see if I care
+void bn_inv(u8 *d, u8 *a, u8 *N, u32 n)
+{
+ u8 t[512], s[512];
+
+ bn_copy(t, N, n);
+ bn_zero(s, n);
+ s[n-1] = 2;
+ bn_sub_modulus(t, s, n);
+ bn_exp(d, a, N, n, t, n);
+}
diff --git a/Source/Core/DolphinWX/Src/MemoryCards/Crypto/ec.cpp b/Source/Core/DolphinWX/Src/MemoryCards/Crypto/ec.cpp
new file mode 100644
index 0000000000..86d9f617b3
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/MemoryCards/Crypto/ec.cpp
@@ -0,0 +1,397 @@
+// Copyright 2007,2008 Segher Boessenkool
+// Licensed under the terms of the GNU GPL, version 2
+// http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
+
+#include
+#include
+#include "Common.h"
+#include "tools.h"
+#include "time.h"
+#include "stdlib.h"
+// y**2 + x*y = x**3 + x + b
+static u8 ec_b[30] =
+ {0x00,0x66,0x64,0x7e,0xde,0x6c,0x33,0x2c,0x7f,0x8c,0x09,0x23,0xbb,0x58,0x21
+ ,0x3b,0x33,0x3b,0x20,0xe9,0xce,0x42,0x81,0xfe,0x11,0x5f,0x7d,0x8f,0x90,0xad};
+
+// order of the addition group of points
+static u8 ec_N[30] =
+ {0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+ ,0x13,0xe9,0x74,0xe7,0x2f,0x8a,0x69,0x22,0x03,0x1d,0x26,0x03,0xcf,0xe0,0xd7};
+
+// base point
+static u8 ec_G[60] =
+ {0x00,0xfa,0xc9,0xdf,0xcb,0xac,0x83,0x13,0xbb,0x21,0x39,0xf1,0xbb,0x75,0x5f
+ ,0xef,0x65,0xbc,0x39,0x1f,0x8b,0x36,0xf8,0xf8,0xeb,0x73,0x71,0xfd,0x55,0x8b
+ ,0x01,0x00,0x6a,0x08,0xa4,0x19,0x03,0x35,0x06,0x78,0xe5,0x85,0x28,0xbe,0xbf
+ ,0x8a,0x0b,0xef,0xf8,0x67,0xa7,0xca,0x36,0x71,0x6f,0x7e,0x01,0xf8,0x10,0x52};
+
+/*static void elt_print(char *name, u8 *a)
+{
+ u32 i;
+
+ printf("%s = ", name);
+
+ for (i = 0; i < 30; i++)
+ printf("%02x", a[i]);
+
+ printf("\n");
+}*/
+
+static void elt_copy(u8 *d, u8 *a)
+{
+ memcpy(d, a, 30);
+}
+
+static void elt_zero(u8 *d)
+{
+ memset(d, 0, 30);
+}
+
+static int elt_is_zero(u8 *d)
+{
+ u32 i;
+
+ for (i = 0; i < 30; i++)
+ if (d[i] != 0)
+ return 0;
+
+ return 1;
+}
+
+static void elt_add(u8 *d, u8 *a, u8 *b)
+{
+ u32 i;
+
+ for (i = 0; i < 30; i++)
+ d[i] = a[i] ^ b[i];
+}
+
+static void elt_mul_x(u8 *d, u8 *a)
+{
+ u8 carry, x, y;
+ u32 i;
+
+ carry = a[0] & 1;
+
+ x = 0;
+ for (i = 0; i < 29; i++) {
+ y = a[i + 1];
+ d[i] = x ^ (y >> 7);
+ x = y << 1;
+ }
+ d[29] = x ^ carry;
+
+ d[20] ^= carry << 2;
+}
+
+static void elt_mul(u8 *d, u8 *a, u8 *b)
+{
+ u32 i, n;
+ u8 mask;
+
+ elt_zero(d);
+
+ i = 0;
+ mask = 1;
+ for (n = 0; n < 233; n++) {
+ elt_mul_x(d, d);
+
+ if ((a[i] & mask) != 0)
+ elt_add(d, d, b);
+
+ mask >>= 1;
+ if (mask == 0) {
+ mask = 0x80;
+ i++;
+ }
+ }
+}
+
+static const u8 square[16] =
+{0x00,0x01,0x04,0x05,0x10,0x11,0x14,0x15,0x40,0x41,0x44,0x45,0x50,0x51,0x54,0x55};
+
+static void elt_square_to_wide(u8 *d, u8 *a)
+{
+ u32 i;
+
+ for (i = 0; i < 30; i++) {
+ d[2*i] = square[a[i] >> 4];
+ d[2*i + 1] = square[a[i] & 15];
+ }
+}
+
+static void wide_reduce(u8 *d)
+{
+ u32 i;
+ u8 x;
+
+ for (i = 0; i < 30; i++) {
+ x = d[i];
+
+ d[i + 19] ^= x >> 7;
+ d[i + 20] ^= x << 1;
+
+ d[i + 29] ^= x >> 1;
+ d[i + 30] ^= x << 7;
+ }
+
+ x = d[30] & ~1;
+
+ d[49] ^= x >> 7;
+ d[50] ^= x << 1;
+
+ d[59] ^= x >> 1;
+
+ d[30] &= 1;
+}
+
+static void elt_square(u8 *d, u8 *a)
+{
+ u8 wide[60];
+
+ elt_square_to_wide(wide, a);
+ wide_reduce(wide);
+
+ elt_copy(d, wide + 30);
+}
+
+static void itoh_tsujii(u8 *d, u8 *a, u8 *b, u32 j)
+{
+ u8 t[30];
+
+ elt_copy(t, a);
+ while (j--) {
+ elt_square(d, t);
+ elt_copy(t, d);
+ }
+
+ elt_mul(d, t, b);
+}
+
+static void elt_inv(u8 *d, u8 *a)
+{
+ u8 t[30];
+ u8 s[30];
+
+ itoh_tsujii(t, a, a, 1);
+ itoh_tsujii(s, t, a, 1);
+ itoh_tsujii(t, s, s, 3);
+ itoh_tsujii(s, t, a, 1);
+ itoh_tsujii(t, s, s, 7);
+ itoh_tsujii(s, t, t, 14);
+ itoh_tsujii(t, s, a, 1);
+ itoh_tsujii(s, t, t, 29);
+ itoh_tsujii(t, s, s, 58);
+ itoh_tsujii(s, t, t, 116);
+ elt_square(d, s);
+}
+
+/*static int point_is_on_curve(u8 *p)
+{
+ u8 s[30], t[30];
+ u8 *x, *y;
+
+ x = p;
+ y = p + 30;
+
+ elt_square(t, x);
+ elt_mul(s, t, x);
+
+ elt_add(s, s, t);
+
+ elt_square(t, y);
+ elt_add(s, s, t);
+
+ elt_mul(t, x, y);
+ elt_add(s, s, t);
+
+ elt_add(s, s, ec_b);
+
+ return elt_is_zero(s);
+}
+*/
+static int point_is_zero(u8 *p)
+{
+ return elt_is_zero(p) && elt_is_zero(p + 30);
+}
+
+static void point_double(u8 *r, u8 *p)
+{
+ u8 s[30], t[30];
+ u8 *px, *py, *rx, *ry;
+
+ px = p;
+ py = p + 30;
+ rx = r;
+ ry = r + 30;
+
+ if (elt_is_zero(px)) {
+ elt_zero(rx);
+ elt_zero(ry);
+
+ return;
+ }
+
+ elt_inv(t, px);
+ elt_mul(s, py, t);
+ elt_add(s, s, px);
+
+ elt_square(t, px);
+
+ elt_square(rx, s);
+ elt_add(rx, rx, s);
+ rx[29] ^= 1;
+
+ elt_mul(ry, s, rx);
+ elt_add(ry, ry, rx);
+ elt_add(ry, ry, t);
+}
+
+static void point_add(u8 *r, u8 *p, u8 *q)
+{
+ u8 s[30], t[30], u[30];
+ u8 *px, *py, *qx, *qy, *rx, *ry;
+
+ px = p;
+ py = p + 30;
+ qx = q;
+ qy = q + 30;
+ rx = r;
+ ry = r + 30;
+
+ if (point_is_zero(p)) {
+ elt_copy(rx, qx);
+ elt_copy(ry, qy);
+ return;
+ }
+
+ if (point_is_zero(q)) {
+ elt_copy(rx, px);
+ elt_copy(ry, py);
+ return;
+ }
+
+ elt_add(u, px, qx);
+
+ if (elt_is_zero(u)) {
+ elt_add(u, py, qy);
+ if (elt_is_zero(u))
+ point_double(r, p);
+ else {
+ elt_zero(rx);
+ elt_zero(ry);
+ }
+
+ return;
+ }
+
+ elt_inv(t, u);
+ elt_add(u, py, qy);
+ elt_mul(s, t, u);
+
+ elt_square(t, s);
+ elt_add(t, t, s);
+ elt_add(t, t, qx);
+ t[29] ^= 1;
+
+ elt_mul(u, s, t);
+ elt_add(s, u, py);
+ elt_add(rx, t, px);
+ elt_add(ry, s, rx);
+}
+
+static void point_mul(u8 *d, u8 *a, u8 *b) // a is bignum
+{
+ u32 i;
+ u8 mask;
+
+ elt_zero(d);
+ elt_zero(d + 30);
+
+ for (i = 0; i < 30; i++)
+ for (mask = 0x80; mask != 0; mask >>= 1) {
+ point_double(d, d);
+ if ((a[i] & mask) != 0)
+ point_add(d, d, b);
+ }
+}
+
+void silly_random(u8 * rndArea, u8 count)
+{
+ u16 i;
+ srand((unsigned) (time(NULL)));
+
+ for(i=0;i= 0)
+ bn_sub_modulus(R, ec_N, 30);
+
+ // S = m**-1*(e + Rk) (mod N)
+
+ elt_copy(kk, k);
+ if (bn_compare(kk, ec_N, 30) >= 0)
+ bn_sub_modulus(kk, ec_N, 30);
+ bn_mul(S, R, kk, ec_N, 30);
+ bn_add(kk, S, e, ec_N, 30);
+ bn_inv(minv, m, ec_N, 30);
+ bn_mul(S, minv, kk, ec_N, 30);
+}
+
+int check_ecdsa(u8 *Q, u8 *R, u8 *S, u8 *hash)
+{
+ u8 Sinv[30];
+ u8 e[30];
+ u8 w1[30], w2[30];
+ u8 r1[60], r2[60];
+
+ bn_inv(Sinv, S, ec_N, 30);
+
+ elt_zero(e);
+ memcpy(e + 10, hash, 20);
+
+ bn_mul(w1, e, Sinv, ec_N, 30);
+ bn_mul(w2, R, Sinv, ec_N, 30);
+
+ point_mul(r1, w1, ec_G);
+ point_mul(r2, w2, Q);
+
+ point_add(r1, r1, r2);
+
+ if (bn_compare(r1, ec_N, 30) >= 0)
+ bn_sub_modulus(r1, ec_N, 30);
+
+ return (bn_compare(r1, R, 30) == 0);
+}
+
+void ec_priv_to_pub(u8 *k, u8 *Q)
+{
+ point_mul(Q, k, ec_G);
+}
diff --git a/Source/Core/DolphinWX/Src/MemoryCards/Crypto/md5.cpp b/Source/Core/DolphinWX/Src/MemoryCards/Crypto/md5.cpp
new file mode 100644
index 0000000000..6f0b438f71
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/MemoryCards/Crypto/md5.cpp
@@ -0,0 +1,570 @@
+/*
+ * RFC 1321 compliant MD5 implementation
+ *
+ * Copyright (C) 2006-2009, Paul Bakker
+ * All rights reserved.
+ *
+ * Joined copyright on original XySSL code with: Christophe Devine
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+/*
+ * The MD5 algorithm was designed by Ron Rivest in 1991.
+ *
+ * http://www.ietf.org/rfc/rfc1321.txt
+ */
+
+//#include "polarssl/config.h"
+
+#if defined(POLARSSL_MD5_C)
+
+#include "polarssl/md5.h"
+#else
+#include "md5.h"
+
+#include
+#include
+
+/*
+ * 32-bit integer manipulation macros (little endian)
+ */
+#ifndef GET_ULONG_LE
+#define GET_ULONG_LE(n,b,i) \
+{ \
+ (n) = ( (unsigned long) (b)[(i) ] ) \
+ | ( (unsigned long) (b)[(i) + 1] << 8 ) \
+ | ( (unsigned long) (b)[(i) + 2] << 16 ) \
+ | ( (unsigned long) (b)[(i) + 3] << 24 ); \
+}
+#endif
+
+#ifndef PUT_ULONG_LE
+#define PUT_ULONG_LE(n,b,i) \
+{ \
+ (b)[(i) ] = (unsigned char) ( (n) ); \
+ (b)[(i) + 1] = (unsigned char) ( (n) >> 8 ); \
+ (b)[(i) + 2] = (unsigned char) ( (n) >> 16 ); \
+ (b)[(i) + 3] = (unsigned char) ( (n) >> 24 ); \
+}
+#endif
+
+/*
+ * MD5 context setup
+ */
+void md5_starts( md5_context *ctx )
+{
+ ctx->total[0] = 0;
+ ctx->total[1] = 0;
+
+ ctx->state[0] = 0x67452301;
+ ctx->state[1] = 0xEFCDAB89;
+ ctx->state[2] = 0x98BADCFE;
+ ctx->state[3] = 0x10325476;
+}
+
+static void md5_process( md5_context *ctx, unsigned char data[64] )
+{
+ unsigned long X[16], A, B, C, D;
+
+ GET_ULONG_LE( X[ 0], data, 0 );
+ GET_ULONG_LE( X[ 1], data, 4 );
+ GET_ULONG_LE( X[ 2], data, 8 );
+ GET_ULONG_LE( X[ 3], data, 12 );
+ GET_ULONG_LE( X[ 4], data, 16 );
+ GET_ULONG_LE( X[ 5], data, 20 );
+ GET_ULONG_LE( X[ 6], data, 24 );
+ GET_ULONG_LE( X[ 7], data, 28 );
+ GET_ULONG_LE( X[ 8], data, 32 );
+ GET_ULONG_LE( X[ 9], data, 36 );
+ GET_ULONG_LE( X[10], data, 40 );
+ GET_ULONG_LE( X[11], data, 44 );
+ GET_ULONG_LE( X[12], data, 48 );
+ GET_ULONG_LE( X[13], data, 52 );
+ GET_ULONG_LE( X[14], data, 56 );
+ GET_ULONG_LE( X[15], data, 60 );
+
+#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
+
+#define P(a,b,c,d,k,s,t) \
+{ \
+ a += F(b,c,d) + X[k] + t; a = S(a,s) + b; \
+}
+
+ A = ctx->state[0];
+ B = ctx->state[1];
+ C = ctx->state[2];
+ D = ctx->state[3];
+
+#define F(x,y,z) (z ^ (x & (y ^ z)))
+
+ P( A, B, C, D, 0, 7, 0xD76AA478 );
+ P( D, A, B, C, 1, 12, 0xE8C7B756 );
+ P( C, D, A, B, 2, 17, 0x242070DB );
+ P( B, C, D, A, 3, 22, 0xC1BDCEEE );
+ P( A, B, C, D, 4, 7, 0xF57C0FAF );
+ P( D, A, B, C, 5, 12, 0x4787C62A );
+ P( C, D, A, B, 6, 17, 0xA8304613 );
+ P( B, C, D, A, 7, 22, 0xFD469501 );
+ P( A, B, C, D, 8, 7, 0x698098D8 );
+ P( D, A, B, C, 9, 12, 0x8B44F7AF );
+ P( C, D, A, B, 10, 17, 0xFFFF5BB1 );
+ P( B, C, D, A, 11, 22, 0x895CD7BE );
+ P( A, B, C, D, 12, 7, 0x6B901122 );
+ P( D, A, B, C, 13, 12, 0xFD987193 );
+ P( C, D, A, B, 14, 17, 0xA679438E );
+ P( B, C, D, A, 15, 22, 0x49B40821 );
+
+#undef F
+
+#define F(x,y,z) (y ^ (z & (x ^ y)))
+
+ P( A, B, C, D, 1, 5, 0xF61E2562 );
+ P( D, A, B, C, 6, 9, 0xC040B340 );
+ P( C, D, A, B, 11, 14, 0x265E5A51 );
+ P( B, C, D, A, 0, 20, 0xE9B6C7AA );
+ P( A, B, C, D, 5, 5, 0xD62F105D );
+ P( D, A, B, C, 10, 9, 0x02441453 );
+ P( C, D, A, B, 15, 14, 0xD8A1E681 );
+ P( B, C, D, A, 4, 20, 0xE7D3FBC8 );
+ P( A, B, C, D, 9, 5, 0x21E1CDE6 );
+ P( D, A, B, C, 14, 9, 0xC33707D6 );
+ P( C, D, A, B, 3, 14, 0xF4D50D87 );
+ P( B, C, D, A, 8, 20, 0x455A14ED );
+ P( A, B, C, D, 13, 5, 0xA9E3E905 );
+ P( D, A, B, C, 2, 9, 0xFCEFA3F8 );
+ P( C, D, A, B, 7, 14, 0x676F02D9 );
+ P( B, C, D, A, 12, 20, 0x8D2A4C8A );
+
+#undef F
+
+#define F(x,y,z) (x ^ y ^ z)
+
+ P( A, B, C, D, 5, 4, 0xFFFA3942 );
+ P( D, A, B, C, 8, 11, 0x8771F681 );
+ P( C, D, A, B, 11, 16, 0x6D9D6122 );
+ P( B, C, D, A, 14, 23, 0xFDE5380C );
+ P( A, B, C, D, 1, 4, 0xA4BEEA44 );
+ P( D, A, B, C, 4, 11, 0x4BDECFA9 );
+ P( C, D, A, B, 7, 16, 0xF6BB4B60 );
+ P( B, C, D, A, 10, 23, 0xBEBFBC70 );
+ P( A, B, C, D, 13, 4, 0x289B7EC6 );
+ P( D, A, B, C, 0, 11, 0xEAA127FA );
+ P( C, D, A, B, 3, 16, 0xD4EF3085 );
+ P( B, C, D, A, 6, 23, 0x04881D05 );
+ P( A, B, C, D, 9, 4, 0xD9D4D039 );
+ P( D, A, B, C, 12, 11, 0xE6DB99E5 );
+ P( C, D, A, B, 15, 16, 0x1FA27CF8 );
+ P( B, C, D, A, 2, 23, 0xC4AC5665 );
+
+#undef F
+
+#define F(x,y,z) (y ^ (x | ~z))
+
+ P( A, B, C, D, 0, 6, 0xF4292244 );
+ P( D, A, B, C, 7, 10, 0x432AFF97 );
+ P( C, D, A, B, 14, 15, 0xAB9423A7 );
+ P( B, C, D, A, 5, 21, 0xFC93A039 );
+ P( A, B, C, D, 12, 6, 0x655B59C3 );
+ P( D, A, B, C, 3, 10, 0x8F0CCC92 );
+ P( C, D, A, B, 10, 15, 0xFFEFF47D );
+ P( B, C, D, A, 1, 21, 0x85845DD1 );
+ P( A, B, C, D, 8, 6, 0x6FA87E4F );
+ P( D, A, B, C, 15, 10, 0xFE2CE6E0 );
+ P( C, D, A, B, 6, 15, 0xA3014314 );
+ P( B, C, D, A, 13, 21, 0x4E0811A1 );
+ P( A, B, C, D, 4, 6, 0xF7537E82 );
+ P( D, A, B, C, 11, 10, 0xBD3AF235 );
+ P( C, D, A, B, 2, 15, 0x2AD7D2BB );
+ P( B, C, D, A, 9, 21, 0xEB86D391 );
+
+#undef F
+
+ ctx->state[0] += A;
+ ctx->state[1] += B;
+ ctx->state[2] += C;
+ ctx->state[3] += D;
+}
+
+/*
+ * MD5 process buffer
+ */
+void md5_update( md5_context *ctx, unsigned char *input, int ilen )
+{
+ int fill;
+ unsigned long left;
+
+ if( ilen <= 0 )
+ return;
+
+ left = ctx->total[0] & 0x3F;
+ fill = 64 - left;
+
+ ctx->total[0] += ilen;
+ ctx->total[0] &= 0xFFFFFFFF;
+
+ if( ctx->total[0] < (unsigned long) ilen )
+ ctx->total[1]++;
+
+ if( left && ilen >= fill )
+ {
+ memcpy( (void *) (ctx->buffer + left),
+ (void *) input, fill );
+ md5_process( ctx, ctx->buffer );
+ input += fill;
+ ilen -= fill;
+ left = 0;
+ }
+
+ while( ilen >= 64 )
+ {
+ md5_process( ctx, input );
+ input += 64;
+ ilen -= 64;
+ }
+
+ if( ilen > 0 )
+ {
+ memcpy( (void *) (ctx->buffer + left),
+ (void *) input, ilen );
+ }
+}
+
+static const unsigned char md5_padding[64] =
+{
+ 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+/*
+ * MD5 final digest
+ */
+void md5_finish( md5_context *ctx, unsigned char output[16] )
+{
+ unsigned long last, padn;
+ unsigned long high, low;
+ unsigned char msglen[8];
+
+ high = ( ctx->total[0] >> 29 )
+ | ( ctx->total[1] << 3 );
+ low = ( ctx->total[0] << 3 );
+
+ PUT_ULONG_LE( low, msglen, 0 );
+ PUT_ULONG_LE( high, msglen, 4 );
+
+ last = ctx->total[0] & 0x3F;
+ padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
+
+ md5_update( ctx, (unsigned char *) md5_padding, padn );
+ md5_update( ctx, msglen, 8 );
+
+ PUT_ULONG_LE( ctx->state[0], output, 0 );
+ PUT_ULONG_LE( ctx->state[1], output, 4 );
+ PUT_ULONG_LE( ctx->state[2], output, 8 );
+ PUT_ULONG_LE( ctx->state[3], output, 12 );
+}
+
+/*
+ * output = MD5( input buffer )
+ */
+void md5( unsigned char *input, int ilen, unsigned char output[16] )
+{
+ md5_context ctx;
+
+ md5_starts( &ctx );
+ md5_update( &ctx, input, ilen );
+ md5_finish( &ctx, output );
+
+ memset( &ctx, 0, sizeof( md5_context ) );
+}
+
+/*
+ * output = MD5( file contents )
+ */
+int md5_file( char *path, unsigned char output[16] )
+{
+ FILE *f;
+ size_t n;
+ md5_context ctx;
+ unsigned char buf[1024];
+
+ if( ( f = fopen( path, "rb" ) ) == NULL )
+ return( 1 );
+
+ md5_starts( &ctx );
+
+ while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
+ md5_update( &ctx, buf, (int) n );
+
+ md5_finish( &ctx, output );
+
+ memset( &ctx, 0, sizeof( md5_context ) );
+
+ if( ferror( f ) != 0 )
+ {
+ fclose( f );
+ return( 2 );
+ }
+
+ fclose( f );
+ return( 0 );
+}
+
+/*
+ * MD5 HMAC context setup
+ */
+void md5_hmac_starts( md5_context *ctx, unsigned char *key, int keylen )
+{
+ int i;
+ unsigned char sum[16];
+
+ if( keylen > 64 )
+ {
+ md5( key, keylen, sum );
+ keylen = 16;
+ key = sum;
+ }
+
+ memset( ctx->ipad, 0x36, 64 );
+ memset( ctx->opad, 0x5C, 64 );
+
+ for( i = 0; i < keylen; i++ )
+ {
+ ctx->ipad[i] = (unsigned char)( ctx->ipad[i] ^ key[i] );
+ ctx->opad[i] = (unsigned char)( ctx->opad[i] ^ key[i] );
+ }
+
+ md5_starts( ctx );
+ md5_update( ctx, ctx->ipad, 64 );
+
+ memset( sum, 0, sizeof( sum ) );
+}
+
+/*
+ * MD5 HMAC process buffer
+ */
+void md5_hmac_update( md5_context *ctx, unsigned char *input, int ilen )
+{
+ md5_update( ctx, input, ilen );
+}
+
+/*
+ * MD5 HMAC final digest
+ */
+void md5_hmac_finish( md5_context *ctx, unsigned char output[16] )
+{
+ unsigned char tmpbuf[16];
+
+ md5_finish( ctx, tmpbuf );
+ md5_starts( ctx );
+ md5_update( ctx, ctx->opad, 64 );
+ md5_update( ctx, tmpbuf, 16 );
+ md5_finish( ctx, output );
+
+ memset( tmpbuf, 0, sizeof( tmpbuf ) );
+}
+
+/*
+ * output = HMAC-MD5( hmac key, input buffer )
+ */
+void md5_hmac( unsigned char *key, int keylen, unsigned char *input, int ilen,
+ unsigned char output[16] )
+{
+ md5_context ctx;
+
+ md5_hmac_starts( &ctx, key, keylen );
+ md5_hmac_update( &ctx, input, ilen );
+ md5_hmac_finish( &ctx, output );
+
+ memset( &ctx, 0, sizeof( md5_context ) );
+}
+
+#if defined(POLARSSL_SELF_TEST)
+/*
+ * RFC 1321 test vectors
+ */
+static unsigned char md5_test_buf[7][81] =
+{
+ { "" },
+ { "a" },
+ { "abc" },
+ { "message digest" },
+ { "abcdefghijklmnopqrstuvwxyz" },
+ { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" },
+ { "12345678901234567890123456789012345678901234567890123456789012" \
+ "345678901234567890" }
+};
+
+static const int md5_test_buflen[7] =
+{
+ 0, 1, 3, 14, 26, 62, 80
+};
+
+static const unsigned char md5_test_sum[7][16] =
+{
+ { 0xD4, 0x1D, 0x8C, 0xD9, 0x8F, 0x00, 0xB2, 0x04,
+ 0xE9, 0x80, 0x09, 0x98, 0xEC, 0xF8, 0x42, 0x7E },
+ { 0x0C, 0xC1, 0x75, 0xB9, 0xC0, 0xF1, 0xB6, 0xA8,
+ 0x31, 0xC3, 0x99, 0xE2, 0x69, 0x77, 0x26, 0x61 },
+ { 0x90, 0x01, 0x50, 0x98, 0x3C, 0xD2, 0x4F, 0xB0,
+ 0xD6, 0x96, 0x3F, 0x7D, 0x28, 0xE1, 0x7F, 0x72 },
+ { 0xF9, 0x6B, 0x69, 0x7D, 0x7C, 0xB7, 0x93, 0x8D,
+ 0x52, 0x5A, 0x2F, 0x31, 0xAA, 0xF1, 0x61, 0xD0 },
+ { 0xC3, 0xFC, 0xD3, 0xD7, 0x61, 0x92, 0xE4, 0x00,
+ 0x7D, 0xFB, 0x49, 0x6C, 0xCA, 0x67, 0xE1, 0x3B },
+ { 0xD1, 0x74, 0xAB, 0x98, 0xD2, 0x77, 0xD9, 0xF5,
+ 0xA5, 0x61, 0x1C, 0x2C, 0x9F, 0x41, 0x9D, 0x9F },
+ { 0x57, 0xED, 0xF4, 0xA2, 0x2B, 0xE3, 0xC9, 0x55,
+ 0xAC, 0x49, 0xDA, 0x2E, 0x21, 0x07, 0xB6, 0x7A }
+};
+
+/*
+ * RFC 2202 test vectors
+ */
+static unsigned char md5_hmac_test_key[7][26] =
+{
+ { "\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B" },
+ { "Jefe" },
+ { "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA" },
+ { "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10"
+ "\x11\x12\x13\x14\x15\x16\x17\x18\x19" },
+ { "\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C" },
+ { "" }, /* 0xAA 80 times */
+ { "" }
+};
+
+static const int md5_hmac_test_keylen[7] =
+{
+ 16, 4, 16, 25, 16, 80, 80
+};
+
+static unsigned char md5_hmac_test_buf[7][74] =
+{
+ { "Hi There" },
+ { "what do ya want for nothing?" },
+ { "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
+ "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
+ "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
+ "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
+ "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD" },
+ { "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
+ "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
+ "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
+ "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
+ "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD" },
+ { "Test With Truncation" },
+ { "Test Using Larger Than Block-Size Key - Hash Key First" },
+ { "Test Using Larger Than Block-Size Key and Larger"
+ " Than One Block-Size Data" }
+};
+
+static const int md5_hmac_test_buflen[7] =
+{
+ 8, 28, 50, 50, 20, 54, 73
+};
+
+static const unsigned char md5_hmac_test_sum[7][16] =
+{
+ { 0x92, 0x94, 0x72, 0x7A, 0x36, 0x38, 0xBB, 0x1C,
+ 0x13, 0xF4, 0x8E, 0xF8, 0x15, 0x8B, 0xFC, 0x9D },
+ { 0x75, 0x0C, 0x78, 0x3E, 0x6A, 0xB0, 0xB5, 0x03,
+ 0xEA, 0xA8, 0x6E, 0x31, 0x0A, 0x5D, 0xB7, 0x38 },
+ { 0x56, 0xBE, 0x34, 0x52, 0x1D, 0x14, 0x4C, 0x88,
+ 0xDB, 0xB8, 0xC7, 0x33, 0xF0, 0xE8, 0xB3, 0xF6 },
+ { 0x69, 0x7E, 0xAF, 0x0A, 0xCA, 0x3A, 0x3A, 0xEA,
+ 0x3A, 0x75, 0x16, 0x47, 0x46, 0xFF, 0xAA, 0x79 },
+ { 0x56, 0x46, 0x1E, 0xF2, 0x34, 0x2E, 0xDC, 0x00,
+ 0xF9, 0xBA, 0xB9, 0x95 },
+ { 0x6B, 0x1A, 0xB7, 0xFE, 0x4B, 0xD7, 0xBF, 0x8F,
+ 0x0B, 0x62, 0xE6, 0xCE, 0x61, 0xB9, 0xD0, 0xCD },
+ { 0x6F, 0x63, 0x0F, 0xAD, 0x67, 0xCD, 0xA0, 0xEE,
+ 0x1F, 0xB1, 0xF5, 0x62, 0xDB, 0x3A, 0xA5, 0x3E }
+};
+
+/*
+ * Checkup routine
+ */
+int md5_self_test( int verbose )
+{
+ int i, buflen;
+ unsigned char buf[1024];
+ unsigned char md5sum[16];
+ md5_context ctx;
+
+ for( i = 0; i < 7; i++ )
+ {
+ if( verbose != 0 )
+ printf( " MD5 test #%d: ", i + 1 );
+
+ md5( md5_test_buf[i], md5_test_buflen[i], md5sum );
+
+ if( memcmp( md5sum, md5_test_sum[i], 16 ) != 0 )
+ {
+ if( verbose != 0 )
+ printf( "failed\n" );
+
+ return( 1 );
+ }
+
+ if( verbose != 0 )
+ printf( "passed\n" );
+ }
+
+ if( verbose != 0 )
+ printf( "\n" );
+
+ for( i = 0; i < 7; i++ )
+ {
+ if( verbose != 0 )
+ printf( " HMAC-MD5 test #%d: ", i + 1 );
+
+ if( i == 5 || i == 6 )
+ {
+ memset( buf, '\xAA', buflen = 80 );
+ md5_hmac_starts( &ctx, buf, buflen );
+ }
+ else
+ md5_hmac_starts( &ctx, md5_hmac_test_key[i],
+ md5_hmac_test_keylen[i] );
+
+ md5_hmac_update( &ctx, md5_hmac_test_buf[i],
+ md5_hmac_test_buflen[i] );
+
+ md5_hmac_finish( &ctx, md5sum );
+
+ buflen = ( i == 4 ) ? 12 : 16;
+
+ if( memcmp( md5sum, md5_hmac_test_sum[i], buflen ) != 0 )
+ {
+ if( verbose != 0 )
+ printf( "failed\n" );
+
+ return( 1 );
+ }
+
+ if( verbose != 0 )
+ printf( "passed\n" );
+ }
+
+ if( verbose != 0 )
+ printf( "\n" );
+
+ return( 0 );
+}
+
+#endif
+
+#endif
diff --git a/Source/Core/DolphinWX/Src/MemoryCards/Crypto/md5.h b/Source/Core/DolphinWX/Src/MemoryCards/Crypto/md5.h
new file mode 100644
index 0000000000..24a02197fa
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/MemoryCards/Crypto/md5.h
@@ -0,0 +1,138 @@
+/**
+ * \file md5.h
+ *
+ * Copyright (C) 2006-2009, Paul Bakker
+ * All rights reserved.
+ *
+ * Joined copyright on original XySSL code with: Christophe Devine
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef POLARSSL_MD5_H
+#define POLARSSL_MD5_H
+
+/**
+ * \brief MD5 context structure
+ */
+typedef struct
+{
+ unsigned long total[2]; /*!< number of bytes processed */
+ unsigned long state[4]; /*!< intermediate digest state */
+ unsigned char buffer[64]; /*!< data block being processed */
+
+ unsigned char ipad[64]; /*!< HMAC: inner padding */
+ unsigned char opad[64]; /*!< HMAC: outer padding */
+}
+md5_context;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \brief MD5 context setup
+ *
+ * \param ctx context to be initialized
+ */
+void md5_starts( md5_context *ctx );
+
+/**
+ * \brief MD5 process buffer
+ *
+ * \param ctx MD5 context
+ * \param input buffer holding the data
+ * \param ilen length of the input data
+ */
+void md5_update( md5_context *ctx, unsigned char *input, int ilen );
+
+/**
+ * \brief MD5 final digest
+ *
+ * \param ctx MD5 context
+ * \param output MD5 checksum result
+ */
+void md5_finish( md5_context *ctx, unsigned char output[16] );
+
+/**
+ * \brief Output = MD5( input buffer )
+ *
+ * \param input buffer holding the data
+ * \param ilen length of the input data
+ * \param output MD5 checksum result
+ */
+void md5( unsigned char *input, int ilen, unsigned char output[16] );
+
+/**
+ * \brief Output = MD5( file contents )
+ *
+ * \param path input file name
+ * \param output MD5 checksum result
+ *
+ * \return 0 if successful, 1 if fopen failed,
+ * or 2 if fread failed
+ */
+int md5_file( char *path, unsigned char output[16] );
+
+/**
+ * \brief MD5 HMAC context setup
+ *
+ * \param ctx HMAC context to be initialized
+ * \param key HMAC secret key
+ * \param keylen length of the HMAC key
+ */
+void md5_hmac_starts( md5_context *ctx, unsigned char *key, int keylen );
+
+/**
+ * \brief MD5 HMAC process buffer
+ *
+ * \param ctx HMAC context
+ * \param input buffer holding the data
+ * \param ilen length of the input data
+ */
+void md5_hmac_update( md5_context *ctx, unsigned char *input, int ilen );
+
+/**
+ * \brief MD5 HMAC final digest
+ *
+ * \param ctx HMAC context
+ * \param output MD5 HMAC checksum result
+ */
+void md5_hmac_finish( md5_context *ctx, unsigned char output[16] );
+
+/**
+ * \brief Output = HMAC-MD5( hmac key, input buffer )
+ *
+ * \param key HMAC secret key
+ * \param keylen length of the HMAC key
+ * \param input buffer holding the data
+ * \param ilen length of the input data
+ * \param output HMAC-MD5 result
+ */
+void md5_hmac( unsigned char *key, int keylen,
+ unsigned char *input, int ilen,
+ unsigned char output[16] );
+
+/**
+ * \brief Checkup routine
+ *
+ * \return 0 if successful, or 1 if the test failed
+ */
+int md5_self_test( int verbose );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* md5.h */
diff --git a/Source/Core/DolphinWX/Src/MemoryCards/Crypto/sha1.cpp b/Source/Core/DolphinWX/Src/MemoryCards/Crypto/sha1.cpp
new file mode 100644
index 0000000000..96845dd8aa
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/MemoryCards/Crypto/sha1.cpp
@@ -0,0 +1,611 @@
+/*
+ * FIPS-180-1 compliant SHA-1 implementation
+ *
+ * Copyright (C) 2006-2009, Paul Bakker
+ * All rights reserved.
+ *
+ * Joined copyright on original XySSL code with: Christophe Devine
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+/*
+ * The SHA-1 standard was published by NIST in 1993.
+ *
+ * http://www.itl.nist.gov/fipspubs/fip180-1.htm
+ */
+/*
+#include "polarssl/config.h"
+
+#if defined(POLARSSL_SHA1_C)
+
+#include "polarssl/sha1.h"
+*/
+#include "sha1.h"
+#include
+#include
+
+/*
+ * 32-bit integer manipulation macros (big endian)
+ */
+#ifndef GET_ULONG_BE
+#define GET_ULONG_BE(n,b,i) \
+{ \
+ (n) = ( (unsigned long) (b)[(i) ] << 24 ) \
+ | ( (unsigned long) (b)[(i) + 1] << 16 ) \
+ | ( (unsigned long) (b)[(i) + 2] << 8 ) \
+ | ( (unsigned long) (b)[(i) + 3] ); \
+}
+#endif
+
+#ifndef PUT_ULONG_BE
+#define PUT_ULONG_BE(n,b,i) \
+{ \
+ (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
+ (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
+ (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
+ (b)[(i) + 3] = (unsigned char) ( (n) ); \
+}
+#endif
+
+/*
+ * SHA-1 context setup
+ */
+void sha1_starts( sha1_context *ctx )
+{
+ ctx->total[0] = 0;
+ ctx->total[1] = 0;
+
+ ctx->state[0] = 0x67452301;
+ ctx->state[1] = 0xEFCDAB89;
+ ctx->state[2] = 0x98BADCFE;
+ ctx->state[3] = 0x10325476;
+ ctx->state[4] = 0xC3D2E1F0;
+}
+
+static void sha1_process( sha1_context *ctx, unsigned char data[64] )
+{
+ unsigned long temp, W[16], A, B, C, D, E;
+
+ GET_ULONG_BE( W[ 0], data, 0 );
+ GET_ULONG_BE( W[ 1], data, 4 );
+ GET_ULONG_BE( W[ 2], data, 8 );
+ GET_ULONG_BE( W[ 3], data, 12 );
+ GET_ULONG_BE( W[ 4], data, 16 );
+ GET_ULONG_BE( W[ 5], data, 20 );
+ GET_ULONG_BE( W[ 6], data, 24 );
+ GET_ULONG_BE( W[ 7], data, 28 );
+ GET_ULONG_BE( W[ 8], data, 32 );
+ GET_ULONG_BE( W[ 9], data, 36 );
+ GET_ULONG_BE( W[10], data, 40 );
+ GET_ULONG_BE( W[11], data, 44 );
+ GET_ULONG_BE( W[12], data, 48 );
+ GET_ULONG_BE( W[13], data, 52 );
+ GET_ULONG_BE( W[14], data, 56 );
+ GET_ULONG_BE( W[15], data, 60 );
+
+#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
+
+#define R(t) \
+( \
+ temp = W[(t - 3) & 0x0F] ^ W[(t - 8) & 0x0F] ^ \
+ W[(t - 14) & 0x0F] ^ W[ t & 0x0F], \
+ ( W[t & 0x0F] = S(temp,1) ) \
+)
+
+#define P(a,b,c,d,e,x) \
+{ \
+ e += S(a,5) + F(b,c,d) + K + x; b = S(b,30); \
+}
+
+ A = ctx->state[0];
+ B = ctx->state[1];
+ C = ctx->state[2];
+ D = ctx->state[3];
+ E = ctx->state[4];
+
+#define F(x,y,z) (z ^ (x & (y ^ z)))
+#define K 0x5A827999
+
+ P( A, B, C, D, E, W[0] );
+ P( E, A, B, C, D, W[1] );
+ P( D, E, A, B, C, W[2] );
+ P( C, D, E, A, B, W[3] );
+ P( B, C, D, E, A, W[4] );
+ P( A, B, C, D, E, W[5] );
+ P( E, A, B, C, D, W[6] );
+ P( D, E, A, B, C, W[7] );
+ P( C, D, E, A, B, W[8] );
+ P( B, C, D, E, A, W[9] );
+ P( A, B, C, D, E, W[10] );
+ P( E, A, B, C, D, W[11] );
+ P( D, E, A, B, C, W[12] );
+ P( C, D, E, A, B, W[13] );
+ P( B, C, D, E, A, W[14] );
+ P( A, B, C, D, E, W[15] );
+ P( E, A, B, C, D, R(16) );
+ P( D, E, A, B, C, R(17) );
+ P( C, D, E, A, B, R(18) );
+ P( B, C, D, E, A, R(19) );
+
+#undef K
+#undef F
+
+#define F(x,y,z) (x ^ y ^ z)
+#define K 0x6ED9EBA1
+
+ P( A, B, C, D, E, R(20) );
+ P( E, A, B, C, D, R(21) );
+ P( D, E, A, B, C, R(22) );
+ P( C, D, E, A, B, R(23) );
+ P( B, C, D, E, A, R(24) );
+ P( A, B, C, D, E, R(25) );
+ P( E, A, B, C, D, R(26) );
+ P( D, E, A, B, C, R(27) );
+ P( C, D, E, A, B, R(28) );
+ P( B, C, D, E, A, R(29) );
+ P( A, B, C, D, E, R(30) );
+ P( E, A, B, C, D, R(31) );
+ P( D, E, A, B, C, R(32) );
+ P( C, D, E, A, B, R(33) );
+ P( B, C, D, E, A, R(34) );
+ P( A, B, C, D, E, R(35) );
+ P( E, A, B, C, D, R(36) );
+ P( D, E, A, B, C, R(37) );
+ P( C, D, E, A, B, R(38) );
+ P( B, C, D, E, A, R(39) );
+
+#undef K
+#undef F
+
+#define F(x,y,z) ((x & y) | (z & (x | y)))
+#define K 0x8F1BBCDC
+
+ P( A, B, C, D, E, R(40) );
+ P( E, A, B, C, D, R(41) );
+ P( D, E, A, B, C, R(42) );
+ P( C, D, E, A, B, R(43) );
+ P( B, C, D, E, A, R(44) );
+ P( A, B, C, D, E, R(45) );
+ P( E, A, B, C, D, R(46) );
+ P( D, E, A, B, C, R(47) );
+ P( C, D, E, A, B, R(48) );
+ P( B, C, D, E, A, R(49) );
+ P( A, B, C, D, E, R(50) );
+ P( E, A, B, C, D, R(51) );
+ P( D, E, A, B, C, R(52) );
+ P( C, D, E, A, B, R(53) );
+ P( B, C, D, E, A, R(54) );
+ P( A, B, C, D, E, R(55) );
+ P( E, A, B, C, D, R(56) );
+ P( D, E, A, B, C, R(57) );
+ P( C, D, E, A, B, R(58) );
+ P( B, C, D, E, A, R(59) );
+
+#undef K
+#undef F
+
+#define F(x,y,z) (x ^ y ^ z)
+#define K 0xCA62C1D6
+
+ P( A, B, C, D, E, R(60) );
+ P( E, A, B, C, D, R(61) );
+ P( D, E, A, B, C, R(62) );
+ P( C, D, E, A, B, R(63) );
+ P( B, C, D, E, A, R(64) );
+ P( A, B, C, D, E, R(65) );
+ P( E, A, B, C, D, R(66) );
+ P( D, E, A, B, C, R(67) );
+ P( C, D, E, A, B, R(68) );
+ P( B, C, D, E, A, R(69) );
+ P( A, B, C, D, E, R(70) );
+ P( E, A, B, C, D, R(71) );
+ P( D, E, A, B, C, R(72) );
+ P( C, D, E, A, B, R(73) );
+ P( B, C, D, E, A, R(74) );
+ P( A, B, C, D, E, R(75) );
+ P( E, A, B, C, D, R(76) );
+ P( D, E, A, B, C, R(77) );
+ P( C, D, E, A, B, R(78) );
+ P( B, C, D, E, A, R(79) );
+
+#undef K
+#undef F
+
+ ctx->state[0] += A;
+ ctx->state[1] += B;
+ ctx->state[2] += C;
+ ctx->state[3] += D;
+ ctx->state[4] += E;
+}
+
+/*
+ * SHA-1 process buffer
+ */
+void sha1_update( sha1_context *ctx, unsigned char *input, int ilen )
+{
+ int fill;
+ unsigned long left;
+
+ if( ilen <= 0 )
+ return;
+
+ left = ctx->total[0] & 0x3F;
+ fill = 64 - left;
+
+ ctx->total[0] += ilen;
+ ctx->total[0] &= 0xFFFFFFFF;
+
+ if( ctx->total[0] < (unsigned long) ilen )
+ ctx->total[1]++;
+
+ if( left && ilen >= fill )
+ {
+ memcpy( (void *) (ctx->buffer + left),
+ (void *) input, fill );
+ sha1_process( ctx, ctx->buffer );
+ input += fill;
+ ilen -= fill;
+ left = 0;
+ }
+
+ while( ilen >= 64 )
+ {
+ sha1_process( ctx, input );
+ input += 64;
+ ilen -= 64;
+ }
+
+ if( ilen > 0 )
+ {
+ memcpy( (void *) (ctx->buffer + left),
+ (void *) input, ilen );
+ }
+}
+
+static const unsigned char sha1_padding[64] =
+{
+ 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+/*
+ * SHA-1 final digest
+ */
+void sha1_finish( sha1_context *ctx, unsigned char output[20] )
+{
+ unsigned long last, padn;
+ unsigned long high, low;
+ unsigned char msglen[8];
+
+ high = ( ctx->total[0] >> 29 )
+ | ( ctx->total[1] << 3 );
+ low = ( ctx->total[0] << 3 );
+
+ PUT_ULONG_BE( high, msglen, 0 );
+ PUT_ULONG_BE( low, msglen, 4 );
+
+ last = ctx->total[0] & 0x3F;
+ padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
+
+ sha1_update( ctx, (unsigned char *) sha1_padding, padn );
+ sha1_update( ctx, msglen, 8 );
+
+ PUT_ULONG_BE( ctx->state[0], output, 0 );
+ PUT_ULONG_BE( ctx->state[1], output, 4 );
+ PUT_ULONG_BE( ctx->state[2], output, 8 );
+ PUT_ULONG_BE( ctx->state[3], output, 12 );
+ PUT_ULONG_BE( ctx->state[4], output, 16 );
+}
+
+/*
+ * output = SHA-1( input buffer )
+ */
+void sha1( unsigned char *input, int ilen, unsigned char output[20] )
+{
+ sha1_context ctx;
+
+ sha1_starts( &ctx );
+ sha1_update( &ctx, input, ilen );
+ sha1_finish( &ctx, output );
+
+ memset( &ctx, 0, sizeof( sha1_context ) );
+}
+
+/*
+ * output = SHA-1( file contents )
+ */
+int sha1_file( char *path, unsigned char output[20] )
+{
+ FILE *f;
+ size_t n;
+ sha1_context ctx;
+ unsigned char buf[1024];
+
+ if( ( f = fopen( path, "rb" ) ) == NULL )
+ return( 1 );
+
+ sha1_starts( &ctx );
+
+ while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
+ sha1_update( &ctx, buf, (int) n );
+
+ sha1_finish( &ctx, output );
+
+ memset( &ctx, 0, sizeof( sha1_context ) );
+
+ if( ferror( f ) != 0 )
+ {
+ fclose( f );
+ return( 2 );
+ }
+
+ fclose( f );
+ return( 0 );
+}
+
+/*
+ * SHA-1 HMAC context setup
+ */
+void sha1_hmac_starts( sha1_context *ctx, unsigned char *key, int keylen )
+{
+ int i;
+ unsigned char sum[20];
+
+ if( keylen > 64 )
+ {
+ sha1( key, keylen, sum );
+ keylen = 20;
+ key = sum;
+ }
+
+ memset( ctx->ipad, 0x36, 64 );
+ memset( ctx->opad, 0x5C, 64 );
+
+ for( i = 0; i < keylen; i++ )
+ {
+ ctx->ipad[i] = (unsigned char)( ctx->ipad[i] ^ key[i] );
+ ctx->opad[i] = (unsigned char)( ctx->opad[i] ^ key[i] );
+ }
+
+ sha1_starts( ctx );
+ sha1_update( ctx, ctx->ipad, 64 );
+
+ memset( sum, 0, sizeof( sum ) );
+}
+
+/*
+ * SHA-1 HMAC process buffer
+ */
+void sha1_hmac_update( sha1_context *ctx, unsigned char *input, int ilen )
+{
+ sha1_update( ctx, input, ilen );
+}
+
+/*
+ * SHA-1 HMAC final digest
+ */
+void sha1_hmac_finish( sha1_context *ctx, unsigned char output[20] )
+{
+ unsigned char tmpbuf[20];
+
+ sha1_finish( ctx, tmpbuf );
+ sha1_starts( ctx );
+ sha1_update( ctx, ctx->opad, 64 );
+ sha1_update( ctx, tmpbuf, 20 );
+ sha1_finish( ctx, output );
+
+ memset( tmpbuf, 0, sizeof( tmpbuf ) );
+}
+
+/*
+ * output = HMAC-SHA-1( hmac key, input buffer )
+ */
+void sha1_hmac( unsigned char *key, int keylen,
+ unsigned char *input, int ilen,
+ unsigned char output[20] )
+{
+ sha1_context ctx;
+
+ sha1_hmac_starts( &ctx, key, keylen );
+ sha1_hmac_update( &ctx, input, ilen );
+ sha1_hmac_finish( &ctx, output );
+
+ memset( &ctx, 0, sizeof( sha1_context ) );
+}
+
+#if defined(POLARSSL_SELF_TEST)
+/*
+ * FIPS-180-1 test vectors
+ */
+static unsigned char sha1_test_buf[3][57] =
+{
+ { "abc" },
+ { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
+ { "" }
+};
+
+static const int sha1_test_buflen[3] =
+{
+ 3, 56, 1000
+};
+
+static const unsigned char sha1_test_sum[3][20] =
+{
+ { 0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E,
+ 0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D },
+ { 0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE,
+ 0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1 },
+ { 0x34, 0xAA, 0x97, 0x3C, 0xD4, 0xC4, 0xDA, 0xA4, 0xF6, 0x1E,
+ 0xEB, 0x2B, 0xDB, 0xAD, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6F }
+};
+
+/*
+ * RFC 2202 test vectors
+ */
+static unsigned char sha1_hmac_test_key[7][26] =
+{
+ { "\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B"
+ "\x0B\x0B\x0B\x0B" },
+ { "Jefe" },
+ { "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
+ "\xAA\xAA\xAA\xAA" },
+ { "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10"
+ "\x11\x12\x13\x14\x15\x16\x17\x18\x19" },
+ { "\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C"
+ "\x0C\x0C\x0C\x0C" },
+ { "" }, /* 0xAA 80 times */
+ { "" }
+};
+
+static const int sha1_hmac_test_keylen[7] =
+{
+ 20, 4, 20, 25, 20, 80, 80
+};
+
+static unsigned char sha1_hmac_test_buf[7][74] =
+{
+ { "Hi There" },
+ { "what do ya want for nothing?" },
+ { "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
+ "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
+ "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
+ "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
+ "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD" },
+ { "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
+ "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
+ "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
+ "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
+ "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD" },
+ { "Test With Truncation" },
+ { "Test Using Larger Than Block-Size Key - Hash Key First" },
+ { "Test Using Larger Than Block-Size Key and Larger"
+ " Than One Block-Size Data" }
+};
+
+static const int sha1_hmac_test_buflen[7] =
+{
+ 8, 28, 50, 50, 20, 54, 73
+};
+
+static const unsigned char sha1_hmac_test_sum[7][20] =
+{
+ { 0xB6, 0x17, 0x31, 0x86, 0x55, 0x05, 0x72, 0x64, 0xE2, 0x8B,
+ 0xC0, 0xB6, 0xFB, 0x37, 0x8C, 0x8E, 0xF1, 0x46, 0xBE, 0x00 },
+ { 0xEF, 0xFC, 0xDF, 0x6A, 0xE5, 0xEB, 0x2F, 0xA2, 0xD2, 0x74,
+ 0x16, 0xD5, 0xF1, 0x84, 0xDF, 0x9C, 0x25, 0x9A, 0x7C, 0x79 },
+ { 0x12, 0x5D, 0x73, 0x42, 0xB9, 0xAC, 0x11, 0xCD, 0x91, 0xA3,
+ 0x9A, 0xF4, 0x8A, 0xA1, 0x7B, 0x4F, 0x63, 0xF1, 0x75, 0xD3 },
+ { 0x4C, 0x90, 0x07, 0xF4, 0x02, 0x62, 0x50, 0xC6, 0xBC, 0x84,
+ 0x14, 0xF9, 0xBF, 0x50, 0xC8, 0x6C, 0x2D, 0x72, 0x35, 0xDA },
+ { 0x4C, 0x1A, 0x03, 0x42, 0x4B, 0x55, 0xE0, 0x7F, 0xE7, 0xF2,
+ 0x7B, 0xE1 },
+ { 0xAA, 0x4A, 0xE5, 0xE1, 0x52, 0x72, 0xD0, 0x0E, 0x95, 0x70,
+ 0x56, 0x37, 0xCE, 0x8A, 0x3B, 0x55, 0xED, 0x40, 0x21, 0x12 },
+ { 0xE8, 0xE9, 0x9D, 0x0F, 0x45, 0x23, 0x7D, 0x78, 0x6D, 0x6B,
+ 0xBA, 0xA7, 0x96, 0x5C, 0x78, 0x08, 0xBB, 0xFF, 0x1A, 0x91 }
+};
+
+/*
+ * Checkup routine
+ */
+int sha1_self_test( int verbose )
+{
+ int i, j, buflen;
+ unsigned char buf[1024];
+ unsigned char sha1sum[20];
+ sha1_context ctx;
+
+ /*
+ * SHA-1
+ */
+ for( i = 0; i < 3; i++ )
+ {
+ if( verbose != 0 )
+ printf( " SHA-1 test #%d: ", i + 1 );
+
+ sha1_starts( &ctx );
+
+ if( i == 2 )
+ {
+ memset( buf, 'a', buflen = 1000 );
+
+ for( j = 0; j < 1000; j++ )
+ sha1_update( &ctx, buf, buflen );
+ }
+ else
+ sha1_update( &ctx, sha1_test_buf[i],
+ sha1_test_buflen[i] );
+
+ sha1_finish( &ctx, sha1sum );
+
+ if( memcmp( sha1sum, sha1_test_sum[i], 20 ) != 0 )
+ {
+ if( verbose != 0 )
+ printf( "failed\n" );
+
+ return( 1 );
+ }
+
+ if( verbose != 0 )
+ printf( "passed\n" );
+ }
+
+ if( verbose != 0 )
+ printf( "\n" );
+
+ for( i = 0; i < 7; i++ )
+ {
+ if( verbose != 0 )
+ printf( " HMAC-SHA-1 test #%d: ", i + 1 );
+
+ if( i == 5 || i == 6 )
+ {
+ memset( buf, '\xAA', buflen = 80 );
+ sha1_hmac_starts( &ctx, buf, buflen );
+ }
+ else
+ sha1_hmac_starts( &ctx, sha1_hmac_test_key[i],
+ sha1_hmac_test_keylen[i] );
+
+ sha1_hmac_update( &ctx, sha1_hmac_test_buf[i],
+ sha1_hmac_test_buflen[i] );
+
+ sha1_hmac_finish( &ctx, sha1sum );
+
+ buflen = ( i == 4 ) ? 12 : 20;
+
+ if( memcmp( sha1sum, sha1_hmac_test_sum[i], buflen ) != 0 )
+ {
+ if( verbose != 0 )
+ printf( "failed\n" );
+
+ return( 1 );
+ }
+
+ if( verbose != 0 )
+ printf( "passed\n" );
+ }
+
+ if( verbose != 0 )
+ printf( "\n" );
+
+ return( 0 );
+}
+
+#endif
+
+//#endif
diff --git a/Source/Core/DolphinWX/Src/MemoryCards/Crypto/sha1.h b/Source/Core/DolphinWX/Src/MemoryCards/Crypto/sha1.h
new file mode 100644
index 0000000000..846a938b41
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/MemoryCards/Crypto/sha1.h
@@ -0,0 +1,138 @@
+/**
+ * \file sha1.h
+ *
+ * Copyright (C) 2006-2009, Paul Bakker
+ * All rights reserved.
+ *
+ * Joined copyright on original XySSL code with: Christophe Devine
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef POLARSSL_SHA1_H
+#define POLARSSL_SHA1_H
+
+/**
+ * \brief SHA-1 context structure
+ */
+typedef struct
+{
+ unsigned long total[2]; /*!< number of bytes processed */
+ unsigned long state[5]; /*!< intermediate digest state */
+ unsigned char buffer[64]; /*!< data block being processed */
+
+ unsigned char ipad[64]; /*!< HMAC: inner padding */
+ unsigned char opad[64]; /*!< HMAC: outer padding */
+}
+sha1_context;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \brief SHA-1 context setup
+ *
+ * \param ctx context to be initialized
+ */
+void sha1_starts( sha1_context *ctx );
+
+/**
+ * \brief SHA-1 process buffer
+ *
+ * \param ctx SHA-1 context
+ * \param input buffer holding the data
+ * \param ilen length of the input data
+ */
+void sha1_update( sha1_context *ctx, unsigned char *input, int ilen );
+
+/**
+ * \brief SHA-1 final digest
+ *
+ * \param ctx SHA-1 context
+ * \param output SHA-1 checksum result
+ */
+void sha1_finish( sha1_context *ctx, unsigned char output[20] );
+
+/**
+ * \brief Output = SHA-1( input buffer )
+ *
+ * \param input buffer holding the data
+ * \param ilen length of the input data
+ * \param output SHA-1 checksum result
+ */
+void sha1( unsigned char *input, int ilen, unsigned char output[20] );
+
+/**
+ * \brief Output = SHA-1( file contents )
+ *
+ * \param path input file name
+ * \param output SHA-1 checksum result
+ *
+ * \return 0 if successful, 1 if fopen failed,
+ * or 2 if fread failed
+ */
+int sha1_file( char *path, unsigned char output[20] );
+
+/**
+ * \brief SHA-1 HMAC context setup
+ *
+ * \param ctx HMAC context to be initialized
+ * \param key HMAC secret key
+ * \param keylen length of the HMAC key
+ */
+void sha1_hmac_starts( sha1_context *ctx, unsigned char *key, int keylen );
+
+/**
+ * \brief SHA-1 HMAC process buffer
+ *
+ * \param ctx HMAC context
+ * \param input buffer holding the data
+ * \param ilen length of the input data
+ */
+void sha1_hmac_update( sha1_context *ctx, unsigned char *input, int ilen );
+
+/**
+ * \brief SHA-1 HMAC final digest
+ *
+ * \param ctx HMAC context
+ * \param output SHA-1 HMAC checksum result
+ */
+void sha1_hmac_finish( sha1_context *ctx, unsigned char output[20] );
+
+/**
+ * \brief Output = HMAC-SHA-1( hmac key, input buffer )
+ *
+ * \param key HMAC secret key
+ * \param keylen length of the HMAC key
+ * \param input buffer holding the data
+ * \param ilen length of the input data
+ * \param output HMAC-SHA-1 result
+ */
+void sha1_hmac( unsigned char *key, int keylen,
+ unsigned char *input, int ilen,
+ unsigned char output[20] );
+
+/**
+ * \brief Checkup routine
+ *
+ * \return 0 if successful, or 1 if the test failed
+ */
+int sha1_self_test( int verbose );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* sha1.h */
diff --git a/Source/Core/DolphinWX/Src/MemoryCards/Crypto/tools.h b/Source/Core/DolphinWX/Src/MemoryCards/Crypto/tools.h
new file mode 100644
index 0000000000..2621b86c29
--- /dev/null
+++ b/Source/Core/DolphinWX/Src/MemoryCards/Crypto/tools.h
@@ -0,0 +1,21 @@
+// Copyright 2007,2008 Segher Boessenkool
+// Licensed under the terms of the GNU GPL, version 2
+// http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
+
+#ifndef _TOOLS_H
+#define _TOOLS_H
+#include "sha1.h"
+
+// bignum
+int bn_compare(u8 *a, u8 *b, u32 n);
+void bn_sub_modulus(u8 *a, u8 *N, u32 n);
+void bn_add(u8 *d, u8 *a, u8 *b, u8 *N, u32 n);
+void bn_mul(u8 *d, u8 *a, u8 *b, u8 *N, u32 n);
+void bn_inv(u8 *d, u8 *a, u8 *N, u32 n); // only for prime N
+void bn_exp(u8 *d, u8 *a, u8 *N, u32 n, u8 *e, u32 en);
+
+void generate_ecdsa(u8 *R, u8 *S, u8 *k, u8 *hash);
+
+void ec_priv_to_pub(u8 *k, u8 *Q);
+
+#endif
diff --git a/Source/Core/DolphinWX/Src/MemoryCards/WiiSaveCrypted.cpp b/Source/Core/DolphinWX/Src/MemoryCards/WiiSaveCrypted.cpp
index f54a1c6a8e..f8283b0460 100644
--- a/Source/Core/DolphinWX/Src/MemoryCards/WiiSaveCrypted.cpp
+++ b/Source/Core/DolphinWX/Src/MemoryCards/WiiSaveCrypted.cpp
@@ -15,47 +15,90 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
-// Based off of tachtig http://git.infradead.org/?p=users/segher/wii.git
+// Based off of tachtig/twintig http://git.infradead.org/?p=users/segher/wii.git
#include "WiiSaveCrypted.h"
#include "FileUtil.h"
+#include "FileUtil.h"
+#include "MathUtil.h"
+
u8 SD_IV[0x10] = {0x21, 0x67, 0x12, 0xE6, 0xAA, 0x1F, 0x68, 0x9F,
0x95, 0xC5, 0xA2, 0x23, 0x24, 0xDC, 0x6A, 0x98};
-
-CWiiSaveCrypted::CWiiSaveCrypted(const char* FileName)
+const u8 SDKey[16] = {0xAB, 0x01, 0xB9, 0xD8, 0xE1, 0x62, 0x2B, 0x08,
+ 0xAF, 0xBA, 0xD8, 0x4D, 0xBF, 0xC2, 0xA5, 0x5D};
+
+u8 MD5_BLANKER[0x10] = {0x0E, 0x65, 0x37, 0x81, 0x99, 0xBE, 0x45, 0x17,
+ 0xAB, 0x06, 0xEC, 0x22, 0x45, 0x1A, 0x57, 0x93};
+CWiiSaveCrypted::CWiiSaveCrypted(const char* FileName, u64 title)
+ : _saveGameTitle(title)
{
- _filename = std::string(FileName);
+ strcpy(pathData_bin, FileName);
+ if (!title)
+ {
+ AES_set_decrypt_key(SDKey, 128, &m_AES_KEY);
- const u8 SDKey[16] = {0xAB, 0x01, 0xB9, 0xD8, 0xE1, 0x62, 0x2B, 0x08,
- 0xAF, 0xBA, 0xD8, 0x4D, 0xBF, 0xC2, 0xA5, 0x5D};
- AES_set_decrypt_key(SDKey, 128, &m_AES_KEY);
- b_valid = true;
- ReadHDR();
- ReadBKHDR();
+
+ do
+ {
+ b_valid = true;
+ ReadHDR();
+ ReadBKHDR();
+ ImportWiiSaveFiles();
+ // TODO: check_sig()
+ if (b_valid)
+ {
+ SuccessAlert("Successfully imported save files");
+ b_tryAgain = false;
+ }
+ else b_tryAgain = AskYesNo("Import failed, try again?");
+ }while(b_tryAgain);
+ }
+ else
+ {
+ AES_set_encrypt_key(SDKey, 128, &m_AES_KEY);
+
+ if (getPaths(true))
+ {
+ do
+ {
+ b_valid = true;
+ WriteHDR();
+ WriteBKHDR();
+ ExportWiiSaveFiles();
+ do_sig();
+ if (b_valid)
+ {
+ SuccessAlert("Successfully exported file to %s", pathData_bin);
+ b_tryAgain = false;
+ }
+ else b_tryAgain = AskYesNo("Export failed, try again?");
+ }while(b_tryAgain);
+ }
+ }
}
void CWiiSaveCrypted::ReadHDR()
{
- saveFileP = fopen(_filename.c_str(), "rb");
- if (!saveFileP)
+ fpData_bin = fopen(pathData_bin, "rb");
+ if (!fpData_bin)
{
- PanicAlert("Cannot open %s", _filename.c_str());
+ PanicAlert("Cannot open %s", pathData_bin);
b_valid = false;
return;
}
- Data_Bin_HDR * tmpHDR = new Data_Bin_HDR;
-
- if (fread(tmpHDR, HDR_SZ, 1, saveFileP) != 1)
+ if (fread(&_encryptedHeader, HEADER_SZ, 1, fpData_bin) != 1)
{
PanicAlert("failed to read header");
b_valid = false;
return;
}
- AES_cbc_encrypt((const u8*)tmpHDR, (u8*)&hdr, HDR_SZ, &m_AES_KEY, SD_IV, AES_DECRYPT);
- delete tmpHDR;
- _bannerSize = Common::swap32(hdr.BannerSize);
+ fclose(fpData_bin);
+
+
+ AES_cbc_encrypt((const u8*)&_encryptedHeader, (u8*)&_header, HEADER_SZ, &m_AES_KEY, SD_IV, AES_DECRYPT);
+ _bannerSize = Common::swap32(_header.hdr.BannerSize);
if ((_bannerSize < FULL_BNR_MIN) || (_bannerSize > FULL_BNR_MAX) ||
(((_bannerSize - BNR_SZ) % ICON_SZ) != 0))
{
@@ -63,151 +106,224 @@ void CWiiSaveCrypted::ReadHDR()
b_valid = false;
return;
}
- _saveGameTitle = Common::swap64(hdr.SaveGameTitle);
- fclose(saveFileP);
+ _saveGameTitle = Common::swap64(_header.hdr.SaveGameTitle);
+
+ memcpy(md5_file, _header.hdr.Md5, 0x10);
+ memcpy(_header.hdr.Md5, MD5_BLANKER, 0x10);
+ md5((u8*)&_header, HEADER_SZ, md5_calc);
+ if (memcmp(md5_file, md5_calc, 0x10))
+ {
+ PanicAlert("MD5 mismatch\n %016llx%016llx != %016llx%016llx", Common::swap64(md5_file),Common::swap64(md5_file+8), Common::swap64(md5_calc), Common::swap64(md5_calc+8));
+ b_valid= false;
+ }
+
+ if (!getPaths())
+ {
+ b_valid = false;
+ return;
+ }
+ if (!File::Exists(pathBanner_bin) || AskYesNo("%s already exists, overwrite?", pathBanner_bin))
+ {
+ INFO_LOG(CONSOLE, "creating file %s", pathBanner_bin);
+ fpBanner_bin = fopen(pathBanner_bin, "wb");
+ if (fpBanner_bin)
+ {
+ fwrite(_header.BNR, _bannerSize, 1, fpBanner_bin);
+ fclose(fpBanner_bin);
+ }
+ }
}
+
+void CWiiSaveCrypted::WriteHDR()
+{
+ if (!b_valid) return;
+ memset(&_header, 0, HEADER_SZ);
+
+ _header.hdr.BannerSize = Common::swap32(File::GetSize(pathBanner_bin));
+
+ _header.hdr.SaveGameTitle = Common::swap64(_saveGameTitle);
+ memcpy(_header.hdr.Md5, MD5_BLANKER, 0x10);
+ _header.hdr.Permissions = 0x3C;//0x35;
+
+ fpBanner_bin = fopen(pathBanner_bin, "rb");
+ if (fpBanner_bin)
+ {
+ if (fread(_header.BNR, Common::swap32(_header.hdr.BannerSize), 1, fpBanner_bin) != 1)
+ {
+ PanicAlert("Failed to read banner.bin");
+ b_valid = false;
+ return;
+ }
+ fclose(fpBanner_bin);
+ }
+
+ md5((u8*)&_header, HEADER_SZ, md5_calc);
+ memcpy(_header.hdr.Md5, md5_calc, 0x10);
+
+ AES_cbc_encrypt((const unsigned char *)&_header, (u8*)&_encryptedHeader, HEADER_SZ, &m_AES_KEY, SD_IV, AES_ENCRYPT);
+ fpData_bin = fopen(pathData_bin, "wb");
+ if (fpData_bin)
+ {
+ if (fwrite(&_encryptedHeader, HEADER_SZ, 1, fpData_bin) != 1)
+ {
+ PanicAlert("Failed to write header for %s", pathData_bin);
+ b_valid = false;
+ }
+ fclose(fpData_bin);
+ }
+}
+
+
+
void CWiiSaveCrypted::ReadBKHDR()
{
if (!b_valid) return;
- saveFileP = fopen(_filename.c_str(), "rb");
- if (!saveFileP)
+
+ fpData_bin = fopen(pathData_bin, "rb");
+ if (!fpData_bin)
{
- PanicAlert("Cannot open %s", _filename.c_str());
+ PanicAlert("Cannot open %s", pathData_bin);
b_valid = false;
return;
}
- fseek(saveFileP, HDR_SZ + FULL_BNR_MAX/*_bannerSize*/, SEEK_SET);
-
- if (fread(&bkhdr, BK_SZ, 1, saveFileP) != 1)
+ fseek(fpData_bin, HEADER_SZ, SEEK_SET);
+ if (fread(&bkhdr, BK_SZ, 1, fpData_bin) != 1)
{
PanicAlert("failed to read bk header");
b_valid = false;
return;
}
+ fclose(fpData_bin);
- if (Common::swap64((u8*)&bkhdr) != 0x00000070426b0001ULL)
+ if (bkhdr.size != Common::swap32(BK_LISTED_SZ) ||
+ bkhdr.magic != Common::swap32(BK_HDR_MAGIC))
{
- PanicAlert("Invalid Size or Magic word %016llx", bkhdr);
+ PanicAlert("Invalid Size(%x) or Magic word (%x)", bkhdr.size, bkhdr.magic);
b_valid = false;
return;
}
- if (_saveGameTitle != Common::swap64(bkhdr.SaveGameTitle))
- WARN_LOG(CONSOLE, "encrypted title (%x) does not match unencrypted title (%x)", _saveGameTitle, Common::swap64(bkhdr.SaveGameTitle));
-
+
_numberOfFiles = Common::swap32(bkhdr.numberOfFiles);
_sizeOfFiles = Common::swap32(bkhdr.sizeOfFiles);
_totalSize = Common::swap32(bkhdr.totalSize);
- fclose(saveFileP);
+
+ if (_sizeOfFiles + FULL_CERT_SZ != _totalSize)
+ WARN_LOG(CONSOLE, "Size(%x) + cert(%x) does not equal totalsize(%x)", _sizeOfFiles, FULL_CERT_SZ, _totalSize);
+ if (_saveGameTitle != Common::swap64(bkhdr.SaveGameTitle))
+ WARN_LOG(CONSOLE, "encrypted title (%x) does not match unencrypted title (%x)", _saveGameTitle, Common::swap64(bkhdr.SaveGameTitle));
+
+
}
-void CWiiSaveCrypted::Extract()
+void CWiiSaveCrypted::WriteBKHDR()
+{
+ if (!b_valid) return;
+ _numberOfFiles = 0;
+ _sizeOfFiles = 0;
+
+ ScanForFiles(pathSavedir, FilesList, &_numberOfFiles, &_sizeOfFiles);
+ memset(&bkhdr, 0, BK_SZ);
+ bkhdr.size = Common::swap32(BK_LISTED_SZ);
+ bkhdr.magic = Common::swap32(BK_HDR_MAGIC);
+//customize this
+ bkhdr.NGid = Common::swap32(1);
+//
+ bkhdr.numberOfFiles = Common::swap32(_numberOfFiles);
+ bkhdr.sizeOfFiles = Common::swap32(_sizeOfFiles);
+ bkhdr.totalSize = Common::swap32(_sizeOfFiles + FULL_CERT_SZ);
+ bkhdr.SaveGameTitle = Common::swap64(_saveGameTitle);
+// customize this
+ const u8 MAC[6] = {0};
+//
+ memcpy(bkhdr.MACaddress, MAC, 6);
+
+ fpData_bin = fopen(pathData_bin, "ab");
+ if(fpData_bin)
+ {
+ if (fwrite(&bkhdr, BK_SZ, 1, fpData_bin) != 1)
+ {
+ PanicAlert("Failed to write bkhdr");
+ b_valid = false;
+ }
+ fclose(fpData_bin);
+ }
+}
+
+void CWiiSaveCrypted::ImportWiiSaveFiles()
{
if (!b_valid) return;
- saveFileP = fopen(_filename.c_str(), "rb");
- if (!saveFileP)
+ fpData_bin = fopen(pathData_bin, "rb");
+ if (!fpData_bin)
{
- PanicAlert("Cannot open %s", _filename.c_str());
+ PanicAlert("Cannot open %s", pathData_bin);
b_valid = false;
return;
}
- sprintf(dir, FULL_WII_USER_DIR "title/%08x/%08x/data/", (u32)(_saveGameTitle>>32), (u32)_saveGameTitle);
-
- if (!AskYesNo("Warning! it is advised to backup all files in the folder:\n%s\nDo you wish to continue?", dir))
- return;
-
- INFO_LOG(CONSOLE, "%s", dir);
- File::CreateFullPath(dir);
-
- fseek(saveFileP, HDR_SZ, SEEK_SET);
-
- _encryptedData = new u8[_bannerSize];
- _data = new u8[_bannerSize];
- if (fread(_encryptedData, _bannerSize, 1, saveFileP) != 1)
- {
- PanicAlert("failed to read banner");
- b_valid = false;
- return;
- }
-
- AES_cbc_encrypt((const u8*)_encryptedData, (u8*)_data, _bannerSize, &m_AES_KEY, SD_IV, AES_DECRYPT);
- delete []_encryptedData;
-
- sprintf(path, "%sbanner.bin", dir);
-
- // remove after code is more thoroughly tested
- sprintf(tmpPath, "%s.bak", path);
- File::Copy(path, tmpPath);
- //
-
- if (!File::Exists(path) || AskYesNo("%s already exists, overwrite?", path))
- {
- INFO_LOG(CONSOLE, "creating file %s", path);
- outFileP = fopen(path, "wb");
- if (outFileP)
- {
- fwrite(_data, _bannerSize, 1, outFileP);
- fclose(outFileP);
- }
- }
- delete []_data;
-
- int lastpos = HDR_SZ + FULL_BNR_MAX /*_bannerSize */+ BK_SZ;
-
-
+ int lastpos = HEADER_SZ + BK_SZ;
FileHDR _tmpFileHDR;
for(u32 i = 0; i < _numberOfFiles; i++)
{
- fseek(saveFileP, lastpos, SEEK_SET);
+ fseek(fpData_bin, lastpos, SEEK_SET);
memset(&_tmpFileHDR, 0, FILE_HDR_SZ);
memset(IV, 0, 0x10);
- u32 roundedsize;
-
- fread(&_tmpFileHDR, FILE_HDR_SZ, 1, saveFileP);
+ _fileSize = 0;
+
+ if (fread(&_tmpFileHDR, FILE_HDR_SZ, 1, fpData_bin) != 1)
+ {
+ PanicAlert("Failed to write header for file %d", i);
+ b_valid = false;
+ }
+
lastpos += FILE_HDR_SZ;
- if(Common::swap32(_tmpFileHDR.magic) != 0x03adf17e)
+ if(Common::swap32(_tmpFileHDR.magic) != FILE_HDR_MAGIC)
{
PanicAlert("Bad File Header");
break;
}
else
{
- sprintf(path, "%s%s", dir, _tmpFileHDR.name);
+ sprintf(pathRawSave, "%s%s", pathSavedir, _tmpFileHDR.name);
+
if (_tmpFileHDR.type == 2)
{
- PanicAlert("savegame with a dir, report me :p, %s", path);
- // we should prolly write any future files to this new dir
- // but tachtig doesnt do this...
- File::CreateFullPath(path);
+ PanicAlert("savegame with a dir, report me :p, %s", pathRawSave);
+ // TODO: tachtig doesnt write future files to this dir
+ // for now, put the rest of the files in the new folder
+ File::CreateFullPath(pathRawSave);
+ strcpy(pathSavedir, pathRawSave);
}
else
{
- roundedsize = (Common::swap32(_tmpFileHDR.size));// + 63) & ~63; // rounding makes corrupted files for NSMBwii
- lastpos += roundedsize;
- _encryptedData = new u8[roundedsize];
- _data = new u8[roundedsize];
- fread(_encryptedData, roundedsize, 1, saveFileP);
- memcpy(IV, _tmpFileHDR.IV, 0x10);
- AES_cbc_encrypt((const unsigned char *)_encryptedData, _data, roundedsize, &m_AES_KEY, IV, AES_DECRYPT);
- delete []_encryptedData;
-
- // remove after code is more thoroughly tested
- sprintf(tmpPath, "%s.bak", path);
- File::Copy(path, tmpPath);
- //
- if (!File::Exists(path) || AskYesNo("%s already exists, overwrite?", path))
+ _fileSize = Common::swap32(_tmpFileHDR.size);
+ lastpos += ROUND_UP(_fileSize, BLOCK_SZ);
+ _encryptedData = new u8[_fileSize];
+ _data = new u8[_fileSize];
+ if (fread(_encryptedData, _fileSize, 1, fpData_bin) != 1)
{
- INFO_LOG(CONSOLE, "creating file %s", path);
+ PanicAlert("Failed to read data from file %d", i);
+ b_valid = false;
+ break;
+ }
+
+
+ memcpy(IV, _tmpFileHDR.IV, 0x10);
+ AES_cbc_encrypt((const unsigned char *)_encryptedData, _data, _fileSize, &m_AES_KEY, IV, AES_DECRYPT);
+ delete []_encryptedData;
- outFileP = fopen(path, "wb");
- if (outFileP)
+ if (!File::Exists(pathRawSave) || AskYesNo("%s already exists, overwrite?", pathRawSave))
+ {
+ INFO_LOG(CONSOLE, "creating file %s", pathRawSave);
+
+ fpRawSaveFile = fopen(pathRawSave, "wb");
+ if (fpRawSaveFile)
{
- fwrite(_data, roundedsize, 1, outFileP);
- fclose(outFileP);
+ fwrite(_data, _fileSize, 1, fpRawSaveFile);
+ fclose(fpRawSaveFile);
}
}
delete []_data;
@@ -215,7 +331,245 @@ void CWiiSaveCrypted::Extract()
}
}
-fclose(saveFileP);
+fclose(fpData_bin);
+}
+
+void CWiiSaveCrypted::ExportWiiSaveFiles()
+{
+ if (!b_valid) return;
+
+ u8 *__ENCdata,
+ *__data;
+
+ for(u32 i = 0; i < _numberOfFiles; i++)
+ {
+ FileHDR tmpFileHDR;
+ std::string __name, __ext;
+ memset(&tmpFileHDR, 0, FILE_HDR_SZ);
+
+ _fileSize = File::GetSize(FilesList.at(i).c_str());
+ _roundedfileSize = ROUND_UP(_fileSize, BLOCK_SZ);
+
+ tmpFileHDR.magic = Common::swap32(FILE_HDR_MAGIC);
+ tmpFileHDR.size = Common::swap32(_fileSize);
+ tmpFileHDR.Permissions = 0x3C;
+ tmpFileHDR.type = File::IsDirectory(FilesList.at(i).c_str()) ? 2 : 1;
+
+ SplitPath(FilesList.at(i), NULL, &__name, &__ext);
+ __name += __ext;
+
+ if (__name.length() > 0x44)
+ {
+ PanicAlert("% is too long for the filename, max chars is 45", __name.c_str());
+ b_valid = false;
+ return;
+ }
+ strncpy((char *)tmpFileHDR.name, __name.c_str(), 0x44);
+
+ fpData_bin = fopen(pathData_bin, "ab");
+ if (fpData_bin)
+ {
+ fwrite(&tmpFileHDR, FILE_HDR_SZ, 1, fpData_bin);
+ fclose(fpData_bin);
+ }
+
+ if (tmpFileHDR.type == 1)
+ {
+ if (_fileSize == 0)
+ {
+ PanicAlert("%s is a 0 byte file", FilesList.at(i).c_str());
+ b_valid = false;
+ return;
+ }
+ fpRawSaveFile = fopen(FilesList.at(i).c_str(), "rb");
+ if (!fpRawSaveFile)
+ {
+ PanicAlert("%s failed to open", FilesList.at(i).c_str());
+ b_valid = false;
+ }
+ __data = new u8[_roundedfileSize];
+ __ENCdata = new u8[_roundedfileSize];
+ memset(__data, 0, _roundedfileSize);
+ if (fread(__data, _fileSize, 1, fpRawSaveFile) != 1)
+ {
+ PanicAlert("failed to read data from file: %s", FilesList.at(i).c_str());
+ b_valid = false;
+ }
+ fclose(fpRawSaveFile);
+
+ AES_cbc_encrypt((const u8*)__data, __ENCdata, _roundedfileSize, &m_AES_KEY, tmpFileHDR.IV, AES_ENCRYPT);
+ fpData_bin = fopen(pathData_bin, "ab");
+ if (fpData_bin)
+ {
+ fwrite(__ENCdata, _roundedfileSize, 1, fpData_bin);
+ fclose(fpData_bin);
+ }
+ delete [] __data;
+ delete [] __ENCdata;
+
+ }
+ }
+}
+
+void CWiiSaveCrypted::do_sig()
+{
+ if (!b_valid) return;
+ u8 sig[0x40];
+ u8 ng_cert[0x180];
+ u8 ap_cert[0x180];
+ u8 hash[0x14];
+ u8 ap_priv[30];
+ u8 ap_sig[60];
+ char signer[64];
+ char name[64];
+ u8 *data;
+ u32 data_size;
+//allow customization
+ u32 ng_id = Common::swap32(1);
+ u32 ng_key_id = Common::swap32(2);
+ u8 ng_sig[0x3C] = {0};
+ u8 ng_priv[0x1E] = {0};
+//allow customization
+
+ sprintf(signer, "Root-CA00000001-MS00000002");
+ sprintf(name, "NG%08x", ng_id);
+ make_ec_cert(ng_cert, ng_sig, signer, name, ng_priv, ng_key_id);
+
+
+ memset(ap_priv, 0, sizeof ap_priv);
+ ap_priv[10] = 1;
+
+ memset(ap_sig, 81, sizeof ap_sig); // temp
+
+ sprintf(signer, "Root-CA00000001-MS00000002-NG%08x", ng_id);
+ sprintf(name, "AP%08x%08x", 1, 2);
+ make_ec_cert(ap_cert, ap_sig, signer, name, ap_priv, 0);
+
+ sha1(ap_cert + 0x80, 0x100, hash);
+ generate_ecdsa(ap_sig, ap_sig + 30, ng_priv, hash);
+ make_ec_cert(ap_cert, ap_sig, signer, name, ap_priv, 0);
+
+ data_size = Common::swap32(bkhdr.sizeOfFiles) + 0x80;
+
+ fpData_bin = fopen(pathData_bin, "rb");
+ if (!fpData_bin)
+ {
+ b_valid = false;
+ return;
+ }
+ data = new u8[data_size];
+
+ fseek(fpData_bin, 0xf0c0, SEEK_SET);
+ if (fread(data, data_size, 1, fpData_bin) != 1)
+ PanicAlert("read data for sig check");
+ sha1(data, data_size, hash);
+ sha1(hash, 20, hash);
+ fclose(fpData_bin);
+ delete []data;
+ fpData_bin = fopen(pathData_bin, "ab");
+ if (!fpData_bin)
+ {
+ b_valid = false;
+ return;
+ }
+ generate_ecdsa(sig, sig + 30, ap_priv, hash);
+ *(u32*)(sig + 60) = Common::swap32(0x2f536969);
+
+
+
+ if (fwrite(sig, sizeof sig, 1, fpData_bin) != 1)
+ PanicAlert("write sig");
+ if (fwrite(ng_cert, sizeof ng_cert, 1, fpData_bin) != 1)
+ PanicAlert("write NG cert");
+ if (fwrite(ap_cert, sizeof ap_cert, 1, fpData_bin) != 1)
+ PanicAlert("write AP cert");
+ fclose(fpData_bin);
+}
+
+
+void CWiiSaveCrypted::make_ec_cert(u8 *cert, u8 *sig, char *signer, char *name, u8 *priv, u32 key_id)
+{
+ memset(cert, 0, 0x180);
+ *(u32*)cert = Common::swap32(0x10002);
+
+ memcpy(cert + 4, sig, 60);
+ strcpy((char*)cert + 0x80, signer);
+ *(u32*)(cert + 0xc0) = Common::swap32(2);
+ strcpy((char*)cert + 0xc4, name);
+ *(u32*)(cert + 0x104) = Common::swap32(key_id);
+ ec_priv_to_pub(priv, cert + 0x108);
+}
+
+bool CWiiSaveCrypted::getPaths(bool _export)
+{
+ if (_saveGameTitle)
+ {
+ sprintf(pathSavedir, FULL_WII_USER_DIR "title/%08x/%08x/data/", (u32)(_saveGameTitle>>32), (u32)_saveGameTitle);
+ sprintf(pathBanner_bin, "%sbanner.bin", pathSavedir);
+ sprintf(_saveGameString, "%c%c%c%c",
+ (u8)(_saveGameTitle >> 24) & 0xFF, (u8)(_saveGameTitle >> 16) & 0xFF,
+ (u8)(_saveGameTitle >> 8) & 0xFF, (u8)_saveGameTitle & 0xFF);
+ }
+ if (_export)
+ {
+ if(!File::IsDirectory(pathSavedir))
+ {
+ b_valid = false;
+ PanicAlert("No save folder found for title %s", _saveGameString);
+ return false;
+ }
+
+ if(!File::Exists(pathBanner_bin))
+ {
+ b_valid = false;
+ PanicAlert("No banner file found for title %s", _saveGameString);
+ return false;
+ }
+ if (strlen(pathData_bin) == 0)
+ strcpy(pathData_bin, ".");// If no path was passed, use current dir
+ sprintf(pathData_bin, "%s/private/wii/title/%s/data.bin", pathData_bin, _saveGameString);
+ File::CreateFullPath(pathData_bin);
+ }
+ else
+ {
+ File::CreateFullPath(pathSavedir);
+ if (!AskYesNo("Warning! it is advised to backup all files in the folder:\n%s\nDo you wish to continue?", pathSavedir))
+ return false;
+ }
+ return true;
+}
+
+void CWiiSaveCrypted::ScanForFiles(std::string savDir, std::vector&FilesList, u32 *_numFiles, u32 *_sizeFiles)
+{
+ std::vector Directories;
+ *_numFiles = *_sizeFiles = 0;
+
+ Directories.push_back(savDir);
+ for (u32 i = 0; i < Directories.size(); i++)
+ {
+ if (i) FilesList.push_back(Directories.at(i));//add dir to fst
+
+ File::FSTEntry FST_Temp;
+ File::ScanDirectoryTree(Directories.at(i).c_str(), FST_Temp);
+ for (u32 j = 0; j < FST_Temp.children.size(); j++)
+ {
+ if (strncmp(FST_Temp.children.at(j).virtualName.c_str(), "banner.bin", 10) != 0 &&
+ strncmp(FST_Temp.children.at(j).virtualName.c_str(), "nocopy", 6) != 0)
+ {
+ (*_numFiles)++;
+ *_sizeFiles += FILE_HDR_SZ + ROUND_UP(FST_Temp.children.at(j).size, BLOCK_SZ);
+
+ if (FST_Temp.children.at(j).isDirectory)
+ {
+ Directories.push_back(FST_Temp.children.at(j).physicalName);
+ }
+ else
+ {
+ FilesList.push_back(FST_Temp.children.at(j).physicalName);
+ }
+ }
+ }
+ }
}
CWiiSaveCrypted::~CWiiSaveCrypted()
diff --git a/Source/Core/DolphinWX/Src/MemoryCards/WiiSaveCrypted.h b/Source/Core/DolphinWX/Src/MemoryCards/WiiSaveCrypted.h
index 1fa4673428..2daffc23dc 100644
--- a/Source/Core/DolphinWX/Src/MemoryCards/WiiSaveCrypted.h
+++ b/Source/Core/DolphinWX/Src/MemoryCards/WiiSaveCrypted.h
@@ -20,6 +20,8 @@
#include "AES/aes.h"
#include "StringUtil.h"
+#include "Crypto/tools.h"
+#include "Crypto/md5.h"
// --- this is used for encrypted Wii save files
@@ -28,48 +30,78 @@
class CWiiSaveCrypted
{
public:
- CWiiSaveCrypted(const char* FileName);
+ CWiiSaveCrypted(const char* FileName, u64 title = 0);
~CWiiSaveCrypted();
void ReadHDR();
void ReadBKHDR();
- void Extract();
+ void WriteHDR();
+ void WriteBKHDR();
+ void Extract(){;}
+ void ImportWiiSaveFiles();
+ void ExportWiiSaveFiles(); // To data.bin
+ void do_sig();
+ void make_ec_cert(u8 *cert, u8 *sig, char *signer, char *name, u8 *priv,
+ u32 key_id);
+ bool getPaths(bool _export = false);
+ void ScanForFiles(std::string savDir, std::vector&FilesList, u32 *_numFiles, u32 *_sizeFiles);
private:
- FILE *saveFileP,
- *outFileP;
AES_KEY m_AES_KEY;
+ std::vector FilesList;
+
+ FILE *fpData_bin,
+ *fpBanner_bin,
+ *fpRawSaveFile;
+
+ char pathData_bin[2048],
+ pathSavedir[2048],
+ pathBanner_bin[2048], //should always be FULL_WII_USER_DIR "title/%08x/%08x/data/"
+ pathRawSave[2048],
+ _saveGameString[5];
u8 IV[0x10],
*_encryptedData,
- *_data;
+ *_data,
+ md5_file[16],
+ md5_calc[16];
- char dir[1024],
- path[1024],
- tmpPath[1024];
-
u32 _bannerSize,
_numberOfFiles,
_sizeOfFiles,
- _totalSize;
+ _totalSize,
+ _fileSize,
+ _roundedfileSize;
u64 _saveGameTitle;
-
- std::string _filename;
- bool b_valid;
+ bool b_valid,
+ b_tryAgain;
enum
{
+ BLOCK_SZ = 0x40,
HDR_SZ = 0x20,
- BK_SZ = 0x80,
- FILE_HDR_SZ = 0x80,
ICON_SZ = 0x1200,
BNR_SZ = 0x60a0,
- FULL_BNR_MIN = 0x72a0, // BNR_SZ + 1*ICON_SZ
- FULL_BNR_MAX = 0xF0A0, // BNR_SZ + 8*ICON_SZ
+ FULL_BNR_MIN = 0x72a0, // BNR_SZ + 1*ICON_SZ
+ FULL_BNR_MAX = 0xF0A0, // BNR_SZ + 8*ICON_SZ
+ HEADER_SZ = 0xF0C0, // HDR_SZ + FULL_BNR_MAX
+ BK_LISTED_SZ = 0x70, // Size before rounding to nearest block
+ BK_SZ = 0x80,
+ FILE_HDR_SZ = 0x80,
+
+ SIG_SZ = 0x40,
+ NG_CERT_SZ = 0x180,
+ AP_CERT_SZ = 0x180,
+ FULL_CERT_SZ = 0x3C0, // SIG_SZ + NG_CERT_SZ + AP_CERT_SZ + 0x80?
+
+
+ BK_HDR_MAGIC = 0x426B0001,
+ FILE_HDR_MAGIC = 0x03adf17e
};
#pragma pack(push,1)
+
struct Data_Bin_HDR // encrypted
{
u64 SaveGameTitle;
@@ -78,13 +110,20 @@ private:
u8 unk1; // maybe permissions is a be16
u8 Md5[0x10]; // md5 of plaintext header with md5 blanker applied
u16 unk2;
- }hdr;
+ };
+
+ struct HEADER
+ {
+ Data_Bin_HDR hdr;
+ u8 BNR[FULL_BNR_MAX];
+ }_header, _encryptedHeader;
struct BK_Header // Not encrypted
{
- u32 size; // 0x00000070
- u16 magic; // 'Bk'
- u16 magic2; // or version (0x0001)
+ u32 size; // 0x00000070
+// u16 magic; // 'Bk'
+// u16 magic2; // or version (0x0001)
+ u32 magic; // 0x426B0001
u32 NGid;
u32 numberOfFiles;
u32 sizeOfFiles;
@@ -93,8 +132,8 @@ private:
u32 totalSize;
u8 unk3[64];
u64 SaveGameTitle;
- u64 MACaddress;
- u8 padding[0x10];
+ u8 MACaddress[6];
+ u8 padding[0x12];
}bkhdr;
struct FileHDR // encrypted
diff --git a/Source/Core/DolphinWX/Src/SConscript b/Source/Core/DolphinWX/Src/SConscript
index 27d6b14fa8..72dc81a852 100644
--- a/Source/Core/DolphinWX/Src/SConscript
+++ b/Source/Core/DolphinWX/Src/SConscript
@@ -37,6 +37,10 @@ if wxenv['HAVE_WX']:
'stdafx.cpp',
'WxUtils.cpp',
'MemoryCards/WiiSaveCrypted.cpp',
+ 'MemoryCards/Crypto/bn.cpp'
+ 'MemoryCards/Crypto/ec.cpp'
+ 'MemoryCards/Crypto/md5.cpp'
+ 'MemoryCards/Crypto/sha1.cpp'
]
CPPDEFINES = [