void Toolbox::ComputeMD5(std::string& result,
const std::string& data)
{
if (data.size() > 0)
{
ComputeMD5(result, &data[0], data.size());
}
else
{
ComputeMD5(result, NULL, 0);
}
}
/* Compute key used by AES
The key is the MD5 hash of the following 0x56 bytes:
<first 0x20 bytes of sector 0> <1-byte block index> <0x35-byte constant>
*/
void Crypt::ComputeEncryptionKey(unsigned char keyOut[16], unsigned char const* tagBlocks0and1, unsigned int blockIndex)
{
// <0x35-byte constant>
unsigned char hashConst[] = {
0x20, 0x43, 0x6F, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x28, 0x43, 0x29, 0x20, 0x32, // Copyright (C) 2
0x30, 0x31, 0x30, 0x20, 0x41, 0x63, 0x74, 0x69, 0x76, 0x69, 0x73, 0x69, 0x6F, 0x6E, 0x2E, 0x20, // 010 Activision.
0x41, 0x6C, 0x6C, 0x20, 0x52, 0x69, 0x67, 0x68, 0x74, 0x73, 0x20, 0x52, 0x65, 0x73, 0x65, 0x72, // All Rights Reser
0x76, 0x65, 0x64, 0x2E, 0x20}; // ved.
const int hashLen = 0x56;
unsigned char hashBuf[hashLen];
unsigned char *numPtr = hashBuf;
memcpy(numPtr, tagBlocks0and1, 0x20);
numPtr += 0x20;
numPtr[0] = (unsigned char)blockIndex;
numPtr += 1;
memcpy(numPtr, hashConst, 0x35);
//fprinthex(stdout,hashBuf, 0x56);
ComputeMD5(keyOut, hashBuf, 0x56);
}
// called from ---NETPLAY--- thread
unsigned int NetPlayClient::OnData(sf::Packet& packet)
{
MessageId mid;
packet >> mid;
switch (mid)
{
case NP_MSG_PLAYER_JOIN:
{
Player player;
packet >> player.pid;
packet >> player.name;
packet >> player.revision;
{
std::lock_guard<std::recursive_mutex> lkp(m_crit.players);
m_players[player.pid] = player;
}
m_dialog->Update();
}
break;
case NP_MSG_PLAYER_LEAVE:
{
PlayerId pid;
packet >> pid;
{
std::lock_guard<std::recursive_mutex> lkp(m_crit.players);
m_players.erase(m_players.find(pid));
}
m_dialog->Update();
}
break;
case NP_MSG_CHAT_MESSAGE:
{
PlayerId pid;
packet >> pid;
std::string msg;
packet >> msg;
// don't need lock to read in this thread
const Player& player = m_players[pid];
// add to gui
std::ostringstream ss;
ss << player.name << '[' << (char)(pid + '0') << "]: " << msg;
m_dialog->AppendChat(ss.str());
}
break;
case NP_MSG_PAD_MAPPING:
{
for (PadMapping& mapping : m_pad_map)
{
packet >> mapping;
}
UpdateDevices();
m_dialog->Update();
}
break;
case NP_MSG_WIIMOTE_MAPPING:
{
for (PadMapping& mapping : m_wiimote_map)
{
packet >> mapping;
}
m_dialog->Update();
}
break;
case NP_MSG_PAD_DATA:
{
PadMapping map = 0;
GCPadStatus pad;
packet >> map >> pad.button >> pad.analogA >> pad.analogB >> pad.stickX >> pad.stickY >>
pad.substickX >> pad.substickY >> pad.triggerLeft >> pad.triggerRight;
// Trusting server for good map value (>=0 && <4)
// add to pad buffer
m_pad_buffer.at(map).Push(pad);
m_gc_pad_event.Set();
}
break;
case NP_MSG_WIIMOTE_DATA:
{
PadMapping map = 0;
NetWiimote nw;
u8 size;
packet >> map >> size;
nw.resize(size);
for (unsigned int i = 0; i < size; ++i)
packet >> nw[i];
// Trusting server for good map value (>=0 && <4)
// add to Wiimote buffer
m_wiimote_buffer.at(map).Push(nw);
m_wii_pad_event.Set();
}
break;
case NP_MSG_PAD_BUFFER:
{
u32 size = 0;
packet >> size;
m_target_buffer_size = size;
m_dialog->OnPadBufferChanged(size);
}
break;
case NP_MSG_CHANGE_GAME:
{
{
std::lock_guard<std::recursive_mutex> lkg(m_crit.game);
packet >> m_selected_game;
}
// update gui
m_dialog->OnMsgChangeGame(m_selected_game);
sf::Packet spac;
spac << static_cast<MessageId>(NP_MSG_GAME_STATUS);
PlayerGameStatus status = m_dialog->FindGame(m_selected_game).empty() ?
PlayerGameStatus::NotFound :
PlayerGameStatus::Ok;
spac << static_cast<u32>(status);
Send(spac);
}
break;
case NP_MSG_GAME_STATUS:
{
PlayerId pid;
packet >> pid;
{
std::lock_guard<std::recursive_mutex> lkp(m_crit.players);
Player& player = m_players[pid];
u32 status;
packet >> status;
player.game_status = static_cast<PlayerGameStatus>(status);
}
m_dialog->Update();
}
break;
case NP_MSG_START_GAME:
{
{
std::lock_guard<std::recursive_mutex> lkg(m_crit.game);
packet >> m_current_game;
packet >> g_NetPlaySettings.m_CPUthread;
packet >> g_NetPlaySettings.m_CPUcore;
packet >> g_NetPlaySettings.m_EnableCheats;
packet >> g_NetPlaySettings.m_SelectedLanguage;
packet >> g_NetPlaySettings.m_OverrideGCLanguage;
packet >> g_NetPlaySettings.m_ProgressiveScan;
packet >> g_NetPlaySettings.m_PAL60;
packet >> g_NetPlaySettings.m_DSPEnableJIT;
packet >> g_NetPlaySettings.m_DSPHLE;
packet >> g_NetPlaySettings.m_WriteToMemcard;
packet >> g_NetPlaySettings.m_OCEnable;
packet >> g_NetPlaySettings.m_OCFactor;
int tmp;
packet >> tmp;
g_NetPlaySettings.m_EXIDevice[0] = (TEXIDevices)tmp;
packet >> tmp;
g_NetPlaySettings.m_EXIDevice[1] = (TEXIDevices)tmp;
u32 time_low, time_high;
packet >> time_low;
packet >> time_high;
g_netplay_initial_rtc = time_low | ((u64)time_high << 32);
}
m_dialog->OnMsgStartGame();
}
break;
case NP_MSG_STOP_GAME:
case NP_MSG_DISABLE_GAME:
{
StopGame();
m_dialog->OnMsgStopGame();
}
break;
case NP_MSG_PING:
{
u32 ping_key = 0;
packet >> ping_key;
sf::Packet spac;
spac << (MessageId)NP_MSG_PONG;
spac << ping_key;
Send(spac);
}
break;
case NP_MSG_PLAYER_PING_DATA:
{
PlayerId pid;
packet >> pid;
{
std::lock_guard<std::recursive_mutex> lkp(m_crit.players);
Player& player = m_players[pid];
packet >> player.ping;
}
DisplayPlayersPing();
m_dialog->Update();
}
break;
case NP_MSG_DESYNC_DETECTED:
{
int pid_to_blame;
u32 frame;
packet >> pid_to_blame;
packet >> frame;
std::string player = "??";
std::lock_guard<std::recursive_mutex> lkp(m_crit.players);
{
auto it = m_players.find(pid_to_blame);
if (it != m_players.end())
player = it->second.name;
}
m_dialog->OnDesync(frame, player);
}
break;
case NP_MSG_SYNC_GC_SRAM:
{
u8 sram[sizeof(g_SRAM.p_SRAM)];
for (size_t i = 0; i < sizeof(g_SRAM.p_SRAM); ++i)
{
packet >> sram[i];
}
{
std::lock_guard<std::recursive_mutex> lkg(m_crit.game);
memcpy(g_SRAM.p_SRAM, sram, sizeof(g_SRAM.p_SRAM));
g_SRAM_netplay_initialized = true;
}
}
break;
case NP_MSG_COMPUTE_MD5:
{
std::string file_identifier;
packet >> file_identifier;
ComputeMD5(file_identifier);
}
break;
case NP_MSG_MD5_PROGRESS:
{
PlayerId pid;
int progress;
packet >> pid;
packet >> progress;
m_dialog->SetMD5Progress(pid, progress);
}
break;
case NP_MSG_MD5_RESULT:
{
PlayerId pid;
std::string result;
packet >> pid;
packet >> result;
m_dialog->SetMD5Result(pid, result);
}
break;
case NP_MSG_MD5_ERROR:
{
PlayerId pid;
std::string error;
packet >> pid;
packet >> error;
m_dialog->SetMD5Result(pid, error);
}
break;
case NP_MSG_MD5_ABORT:
{
m_should_compute_MD5 = false;
m_dialog->AbortMD5();
}
break;
default:
PanicAlertT("Unknown message received with id : %d", mid);
break;
}
return 0;
}
