int main (int argc, char *argv[])
{
//check usage
if (argc >= 3)
{
fprintf(stderr,"Usage: %s \"text\"\n", argv[0]);
exit(1);
}
//if no arguments, use text from homework #6
else if (argc == 1)
{
char message[] = "Libi imycibqwvm ycwbkcvycm ntcmvbma ycivbqbibma"
" qvdwtdmvbm, ntcfqwvma qvdmvqzm: mb dqkm dmzai";
for (int i = 1; i <= KEYSPACE; i++)
{
printf("key %2d\nciphertxt: ", i);
caesar(i, message);
}
printf("\"key = 18 looks Latin to me\"\n\n");
}
//if present, use first argument as text
else if (argc == 2)
{
for (int i = 1; i <= KEYSPACE; i++)
{
printf("key %2d\nciphertxt: ", i);
caesar(i, argv[1]);
}
}
return 0;
}
static void pre_treat(void){
char c_work;
int n_work;
FILE *fp_source;
FILE *fp_worked;
fp_source=Sfopen("source.txt");
fp_worked=fopen("worked.txt","w+");
Total_Number=0;
n_work = 0 ;
while(1){
c_work=getc(fp_source);
n_work=caesar(c_work);
if(n_work!= -1){
fprintf(fp_worked,"%d\n",n_work);
Total_Number++;
}
else{
break;
}
}
fclose(fp_source);
fp_source=NULL;
while(Total_Number % configuration.BITWIDTH != 0){
fprintf(fp_worked,"%d\n",2);
Total_Number++;
}
fclose(fp_worked);
fp_worked=NULL;
}
int main(void){
char str[] = "Hallz";
caesar(str, 5);
printf("%s\n", str);
}
int main() {
char buf[1000];
while(scanf("%1000s", buf)) {
caesar(buf);
}
return 0;
}
int main (void)
{
char message[] = "Sp S rkn kcuon zoyzvo grkd droi gkxdon, droi gyevn rkfo cksn pkcdob rybcoc.";
for (int key = 0; key < 26; key++)
{
caesar (message, key);
}
return 0;
}
int main(void)
{
char str[MAX_LEN+1];
while ( fgets(str, MAX_LEN, stdin) != NULL ) {
caesar(str);
printf("%s", str);
}
return 0;
}
int main(int argc, char *argv[])
{
if (argc > 3 || argc < 2) //Only accept one or two arguments, '-d' for decrypt should not come last
{
printf("Usage: %s [-d decrypt] KEY\n\tKEY is an alphabetical phrase.\n\tEncrypts stdin using a vigenere cipher.\n", argv[0]);
return 1;
}
char *key_in = argv[argc - 1]; //Take the last command line argument as key
char intext[MESSAGE_MAX_LENGTH];
fgets(intext, MESSAGE_MAX_LENGTH, stdin);
for (int i = 0, n = 0; i < strlen(intext); i++, n++)
{
if (n == strlen(argv[argc - 1]))
n = 0;
if (isalnum(intext[i]) == 0)
--n;
if (!strcmp(argv[1], "-d"))
printf("%c", caesar(v_key(argv[argc - 1][n], 1), intext[i]));
else
printf("%c", caesar(v_key(argv[argc - 1][n], 0), intext[i]));
}
}
int main(int argc, char* argv[]) {
if(argc < 3) {
printf("Usage: caesar <key> <clear-text>");
return 0;
}
int key = atoi(argv[1]);
printf("clear: %s\n", argv[2]);
caesar(key, argv[2]);
printf("cipher: %s\n", argv[2]);
}
int main(int argc, string argv[]){
do{
if (argc != 2){
printf("You need to submit a valid encryption key.\n");
return 1 ;
}else {
key = atoi(argv[1]);
plainText = GetString();
caesar(plainText, key);
success = true;
}
}while(!success);
//printf("What is the level of encryption that you want ? \n");
return 0;
}
void cipherGen(int type[])
{
switch(type[0])
{
case 1:
rot13();
break;
case 2:
mono();
break;
case 3:
caesar();
break;
default:
printf("Invalid cipher type");
}
}
void choice()
{
printf("\n ");
printf("\n \t \t \t \t Menu");
printf("\n ");
printf("\n \t \t \t1.Simple Cryptography");
printf("\n ");
printf("\n \t \t \t2.Difficult Cryptography");
printf("\n ");
printf("\n \t \t \t3.Exit");
printf("\n ");
int ch,flag=1;
printf("\n \t \t \tEnter the choice of Cryptography\n \t \t \t");
scanf("%d",&ch);
switch(ch)
{
case 1:caesar();
break;
case 2:RSA();
break;
case 3:exit(0);
default: printf("\n \t \t \tInvalid Choice");
printf("\n ");
flag=0;
}
if(flag==0)
{
int i;
system("cls"); //Used to clear the console
printf("\n \t \t \tInvalid Choice please wait");
for (i=0;i<4;i++)
{
delay();
printf(".");
}
system("cls");
choice();
}
}
/**
* When someone writes to the driver file
*/
ssize_t trans_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
printk(KERN_INFO "WRITE: Starte schreiben von %d Zeichen.\n", count);
// Get device from driver file
struct trans_dev *dev = filp->private_data;
int bytes_written = 0;
// Writeloop for required bytes to write
for(bytes_written = 0; (bytes_written < count); bytes_written++){
// Check for condition variable to be sure we can write (e.g. buffer is full, so we'd have to wait)
if(!WRITE_POSSIBLE){
// IF we should not block error out as we're forced to block
if(filp->f_flags&O_NONBLOCK){
return -EAGAIN;
}
// Wait for condition
if(wait_event_interruptible(dev->write_queue,WRITE_POSSIBLE)){
return -ERESTARTSYS;
}
}
// Get current character
char tmp = *buf;
// Get character from userspace into kernelspace
get_user(*(dev->p_in), buf++);
// Shift character
*dev->p_in = caesar(*dev->p_in,dev->shift);
// Move to empty character
dev->p_in++;
// Increase count of buffered characters
dev->count++;
printk(KERN_INFO "WRITE: schreibe zeichen %d\n", bytes_written + 1);
// If buffer is full, move cached data to buffer
if(((dev->p_in - dev->data) % BUF_LEN) == 0){
dev->p_in = dev->data;
}
// Notify read process to have more data to read
wake_up_interruptible(&dev->read_queue);
}
printk(KERN_INFO "WRITE: %d konnten nicht geschrieben werden\n", count - bytes_written);
// Return written bytes
return bytes_written;
}
int main(int argc, string argv[]) {
// Variable declarations
bool keySuccessful = false;
string keyword = "";
int keylength = 0;
string user_text = "";
int user_text_length;
int key_count = 0;
do
{
// The number of command line args submitted was incorrect.
if(argc != 2)
{
printf("You didn't enter the correct number of keywords.\n");
return 1;
}
else if(argv[1])
{
int length = strlen(argv[1]);
for(int i = 0; i < length; i++)
{
if(!isalpha(argv[1][i]))
{
// We accept only letters as input.
printf("Your input contains illegal characters.\n");
return 1;
}
else
{
// All good, input can be accepted as key.
keySuccessful = true;
keyword = argv[1];
}
}
}
} while(!keySuccessful);
// We check for the length of the keyword and define an array with that length.
keylength = strlen(keyword);
int keycodes[keylength];
// The letters in the keyword array should be converted to numbers
// starting from A = 0 to Z = 25 ignoring case.
for(int i = 0; i < keylength;i++)
{
keycodes[i] = toupper(keyword[i]) - 65;
}
// Read in user text and calculate its length.
user_text = GetString();
user_text_length = strlen(user_text);
for (int i = 0; i < user_text_length; i++)
{
// If input at given position is not letter, just mirror it.
if(!isalpha(user_text[i]))
{
printf("%c", user_text[i]);
}
// Process input.
else
{
printf("%c", caesar(user_text[i], keycodes[key_count]));
// Increase the position counter for the keycode array.
if(key_count < keylength - 1)
{
key_count++;
}
else
{
key_count = 0;
}
}
}
// Be a nice citizen and exit cleanly.
printf("\n");
return 0;
}
void GameDataHolder::Impl::Flush()
{
if( !FileExist( "save" ) ){
CreateDirectory( "save" );
}
UpdatePlayTime();
std::vector < char > data;
data.reserve( 30000 );
std::ofstream fOut( m_SaveDataFileName, std::ios::binary | std::ios::out );
if( !fOut ){
return;
}
CopyInt( &data, m_GameFileData.m_PlayTime );
CopyInt( &data, m_GameFileData.m_Progress );
for( int i = 0; i < GAME_DIFFICULTY_TOTAL; ++i ){
// 通常プレイの統計情報の保存
CopyInt( &data, m_GameFileData.m_Difficulty[ i ].m_NormalPlayStat.m_Play );
CopyInt( &data, m_GameFileData.m_Difficulty[ i ].m_NormalPlayStat.m_AllClear );
CopyInt( &data, m_GameFileData.m_Difficulty[ i ].m_NormalPlayStat.m_PlayTime );
CopyInt( &data, m_GameFileData.m_Difficulty[ i ].m_NormalPlayStat.m_Progress );
for( int j = 0; j < STAGE_TOTAL; ++j ){
// 敵情報の保存
const StageStat& stage = m_GameFileData.m_Difficulty[ i ].m_NormalPlayStat.m_StageStat[ j ];
StageStat::EnemyStatMap::const_iterator it = stage.m_EnemyStat.begin();
// エントリ数の保存
CopyInt( &data, stage.m_EnemyStat.size() );
for( ; it != stage.m_EnemyStat.end(); ++it ){
// 敵の名前の長さ保存
CopyInt( &data, it->first.size() );
// 敵の名前の保存
CopyArray( &data, it->first.c_str(), it->first.size() );
// 情報の保存
CopyInt( &data, it->second.m_Destroy );
CopyInt( &data, it->second.m_Damaged );
CopyInt( &data, it->second.m_KO );
}
}
// ステージ選択プレイの統計情報の保存
CopyInt( &data, m_GameFileData.m_Difficulty[ i ].m_StageSelectionPlayStat.m_Play );
CopyInt( &data, m_GameFileData.m_Difficulty[ i ].m_StageSelectionPlayStat.m_Clear );
CopyInt( &data, m_GameFileData.m_Difficulty[ i ].m_StageSelectionPlayStat.m_PlayTime );
for( int j = 0; j < STAGE_TOTAL; ++j ){
// 敵情報の保存
const StageStat& stage = m_GameFileData.m_Difficulty[ i ].m_StageSelectionPlayStat.m_StageStat[ j ];
StageStat::EnemyStatMap::const_iterator it = stage.m_EnemyStat.begin();
// エントリ数の保存
CopyInt( &data, stage.m_EnemyStat.size() );
for( ; it != stage.m_EnemyStat.end(); ++it ){
// 敵の名前の長さ保存
CopyInt( &data, it->first.size() );
// 敵の名前の保存
CopyArray( &data, it->first.c_str(), it->first.size() );
// 情報の保存
CopyInt( &data, it->second.m_Destroy );
CopyInt( &data, it->second.m_Damaged );
CopyInt( &data, it->second.m_KO );
}
}
// スコアの保存
for( int j = 0; j < MAX_SCORE_ENTRY; ++j ){
SaveDataRecord record = m_GameFileData.m_Difficulty[ i ].m_Record[ j ];
CopyArray( &data, record.m_Name, sizeof( record.m_Name ) );
CopyInt( &data, record.m_Date.m_Year );
data.push_back( record.m_Date.m_Month );
data.push_back( record.m_Date.m_Day );
data.push_back( record.m_Date.m_Hour );
data.push_back( record.m_Date.m_Min );
data.push_back( record.m_Date.m_Sec );
for( int k = 0; k < STAGE_TOTAL; ++k ){
SaveDataRecord::StageData stage = record.m_StageData[ k ];
CopyInt( &data, stage.m_Score );
CopyInt( &data, stage.m_Killed );
CopyInt( &data, stage.m_Crystal );
CopyInt( &data, stage.m_CrystalUsed );
CopyInt( &data, stage.m_Progress );
}
CopyInt( &data, record.m_Score );
CopyInt( &data, record.m_Progress );
CopyInt( &data, record.m_Killed );
CopyInt( &data, record.m_Crystal );
CopyInt( &data, record.m_CrystalUsed );
}
}
// 圧縮
char* pBuf = new char [ data.size() * 2 ];
int compSize = 0;
MAPIL::LZ lz( 200, 3 );
lz.Compress( &data[ 0 ], data.size(), &pBuf, data.size() * 2, &compSize );
// シーザ暗号化
MAPIL::Caesar caesar( 10 );
caesar.Encrypt( pBuf, compSize );
// XOR暗号化
MAPIL::XOR xor( 60 );
xor.Encrypt( pBuf, compSize );
fOut.write( pBuf, compSize );
fOut.close();
MAPIL::SafeDeleteArray( pBuf );
}
void GameDataHolder::Impl::Load( const std::string& fileName )
{
// 現在時刻を取得
m_TimeStamp = ::time( NULL );
std::fstream fIn( m_SaveDataFileName, std::ios::binary | std::ios::in );
if( !fIn ){
return;
}
int size = GetFileSize( fIn );
char* pBuf = new char [ size ];
fIn.read( pBuf, size * sizeof( char ) );
fIn.close();
// XOR暗号復号化
MAPIL::XOR xor( 60 );
xor.Decrypt( pBuf, size );
// シーザ暗号復号化
MAPIL::Caesar caesar( 10 );
caesar.Decrypt( pBuf, size );
// 解凍
MAPIL::LZ lz( 200, 3 );
char* pData = new char [ size * 1000 ];
int dataSize = 0;
lz.Expand( pBuf, size, &pData, size * 1000, &dataSize );
MAPIL::SafeDeleteArray( pBuf );
// データ設定
char* p = pData;
m_GameFileData.m_PlayTime = GetInt( &p );
m_GameFileData.m_Progress = GetInt( &p );
for( int i = 0; i < GAME_DIFFICULTY_TOTAL; ++i ){
GameFileData::Difficulty difficulty;
// 通常プレイのデータを取得
difficulty.m_NormalPlayStat.m_Play = GetInt( &p );
difficulty.m_NormalPlayStat.m_AllClear = GetInt( &p );
difficulty.m_NormalPlayStat.m_PlayTime = GetInt( &p );
difficulty.m_NormalPlayStat.m_Progress = GetInt( &p );
for( int j = 0; j < STAGE_TOTAL; ++j ){
// 敵情報の取得
StageStat& stage = difficulty.m_NormalPlayStat.m_StageStat[ j ];
// エントリ数の取得
int entry = GetInt( &p );
for( int k = 0; k < entry; ++k ){
// 敵の名前の長さを取得
int length = GetInt( &p );
// 敵の名前の取得
char* pEnemyName = new char[ length + 1 ];
::memcpy( pEnemyName, p, sizeof( length ) );
pEnemyName[ length ] = '\0';
p += length;
// 情報の取得
EnemyStat enemyStat;
enemyStat.m_Destroy = GetInt( &p );
enemyStat.m_Damaged = GetInt( &p );
enemyStat.m_KO = GetInt( &p );
stage.m_EnemyStat[ pEnemyName ] = enemyStat;
MAPIL::SafeDeleteArray( pEnemyName );
}
}
// ステージ選択プレイのデータを取得
difficulty.m_StageSelectionPlayStat.m_Play = GetInt( &p );
difficulty.m_StageSelectionPlayStat.m_Clear = GetInt( &p );
difficulty.m_StageSelectionPlayStat.m_PlayTime = GetInt( &p );
for( int j = 0; j < STAGE_TOTAL; ++j ){
// 敵情報の取得
StageStat& stage = difficulty.m_StageSelectionPlayStat.m_StageStat[ j ];
// エントリ数の取得
int entry = GetInt( &p );
for( int k = 0; k < entry; ++k ){
// 敵の名前の長さを取得
int length = GetInt( &p );
// 敵の名前の取得
char* pEnemyName = new char[ length + 1 ];
::memcpy( pEnemyName, p, sizeof( length ) );
pEnemyName[ length ] = '\0';
p += length;
// 情報の取得
EnemyStat enemyStat;
enemyStat.m_Destroy = GetInt( &p );
enemyStat.m_Damaged = GetInt( &p );
enemyStat.m_KO = GetInt( &p );
stage.m_EnemyStat[ pEnemyName ] = enemyStat;
MAPIL::SafeDeleteArray( pEnemyName );
}
}
// スコアのロード
for( int j = 0; j < MAX_SCORE_ENTRY; ++j ){
SaveDataRecord record;
::memcpy( record.m_Name, p, sizeof( record.m_Name ) );
p += sizeof( record.m_Name );
record.m_Date.m_Year = GetInt( &p );
record.m_Date.m_Month = *p++;
record.m_Date.m_Day = *p++;
record.m_Date.m_Hour = *p++;
record.m_Date.m_Min = *p++;
record.m_Date.m_Sec = *p++;
for( int k = 0; k < STAGE_TOTAL; ++k ){
SaveDataRecord::StageData stage;
stage.m_Score = GetInt( &p );
stage.m_Killed = GetInt( &p );
stage.m_Crystal = GetInt( &p );
stage.m_CrystalUsed = GetInt( &p );
stage.m_Progress = GetInt( &p );
record.m_StageData[ k ] = stage;
}
record.m_Score = GetInt( &p );
record.m_Progress = GetInt( &p );
record.m_Killed = GetInt( &p );
record.m_Crystal = GetInt( &p );
record.m_CrystalUsed = GetInt( &p );
difficulty.m_Record[ j ] = record;
}
m_GameFileData.m_Difficulty[ i ] = difficulty;
}
MAPIL::SafeDeleteArray( pData );
}
