ATA（代码）

最新推荐文章于 2021-12-07 18:33:57 发布
最新推荐文章于 2021-12-07 18:33:57 发布
阅读量1.5k 收藏
点赞数
分类专栏： 专业成长历程 文章标签： fp exchange c string null 加密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jasmine1987/article/details/1796373
版权
  1. 编码转换：GBK码转UCS2码    和 UCS2码转GBK码（第一次用类来写，封装得很糟糕）
  2. #include <string.h>
    #include <iostream.h>

    #define N 100
    class coding
    {
    public:
        coding()
        {
           
        }
        ~coding()
        {

        }
        void Initunstr(char *string)
        {
           
            unstr=string;
            length=strlen(unstr);
        }
        void Initstr(char *string)
        {
            str=string;
            length=strlen(string);
        }
        void UCS2_GBK()
        {
            if(length == 0)
                exit(1);
            char buf[N];
            ZeroMemory(buf,N);        
            int i,len;
            //高低字节交换位置
            for(i = 0; i < length-1; i += 2)
            {
                buf[i+1]=unstr[i];
                buf[i]=unstr[i+1];
            }
            len = WideCharToMultiByte(CP_ACP, 0L, (unsigned short *)&buf[0], -1, unstr, 0, NULL, NULL);  
            str=(char *)malloc(len*sizeof(char)+1);
            WideCharToMultiByte(CP_ACP, 0L, (unsigned short *)&buf[0], -1, str, len, NULL, NULL);       

        }
        void GBK_UCS2()
        {
            if(!length)
                exit(1);
            char buf[N],*buftemp;
            ZeroMemory(buf,N);
            int i, len;
            len=MultiByteToWideChar(CP_ACP,0L,str,-1, (unsigned short *)&buf[0], 0);
            MultiByteToWideChar(CP_ACP,0L,str,-1, (unsigned short *)&buf[0], len);
            unstr=(char *)malloc(2*len*sizeof(char));
            buftemp=(char *)malloc(2*len*sizeof(char));
           
            len--;
            for(i=0;i < (len*2); i += 2)
            {
                buftemp[i]=buf[i+1];
                buftemp[i+1]=buf[i];
            }
            for(i=0;i< 2*len;i++)

                unstr[i]=buftemp[i];
            unstr[i]='/0';

           
        }
        char * getstr()
        {
            return str;
        }
        char* getunstr()
        {
            return unstr;
        }
    private:
       
        char *str;
        char *unstr;
        int length;
    };   

    /*int main()
    {
        coding code;
        char *string=new char(N);
        cin>>string;
        code.Initunstr(string);
        code.UCS2_GBK();
    //    code.printstr();
    //    code.Initstr("慢");
    //    code.GBK_UCS2();
        string=code.getstr();
        cout<<string<<endl;
        code.Initstr(string);
        code.GBK_UCS2();
        cout<<code.getunstr()<<endl;
        return 0;
    }*/
  3. MD5算法加密  核心是网上搜来的，里面涉及到很多宏定义，本想拆成const，但是这个编译时还有类型检查，很难实现，于是就放一块了，做成了.hpp文件，直接调用函数就好
  4. /*我做的修改就是接口的更改！**/
    /*让它接受已个字符串然后将该字符串加密处理的信息以字符串形式输出*/
    /*设计思想是通过中间文件进行转换，先将字符串写入文件，再让代码处理文件加密，再将加密信息读入文件，再将信息从文件中读出*/
    /*这个是HPP文件，也就是算法的实现过程，test是个测试函数*/
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <assert.h>

    #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
    #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
    #define H(x, y, z) ((x) ^ (y) ^ (z))
    #define I(x, y, z) ((y) ^ ((x) | (~z)))

    #define RL(x, y) (((x) << (y)) | ((x) >> (32 - (y))))  //x向左循环移y位

    #define PP(x) (x<<24)|((x<<8)&0xff0000)|((x>>8)&0xff00)|(x>>24)  //将x高低位互换,例如PP(aabbccdd)=ddccbbaa

    #define FF(a, b, c, d, x, s, ac) a = b + (RL((a + F(b,c,d) + x + ac),s))
    #define GG(a, b, c, d, x, s, ac) a = b + (RL((a + G(b,c,d) + x + ac),s))
    #define HH(a, b, c, d, x, s, ac) a = b + (RL((a + H(b,c,d) + x + ac),s))
    #define II(a, b, c, d, x, s, ac) a = b + (RL((a + I(b,c,d) + x + ac),s))

    unsigned A,B,C,D,a,b,c,d,i,len,flen[2],x[16];   //i临时变量,len文件长,flen[2]为64位二进制表示的文件初始长度
    char FileName[]="temp.dat";   //文件名
    FILE *fp;
    void ChangeToFile(const char *s)
    {
        fp=fopen(FileName,"w+");
        if(fp==NULL)
        {
            printf("The temp file can't creat!/n");
            exit(0);
        }
        else
        {
            fprintf(fp,"%s",s);
            fclose(fp);
        }
    }

    //MD5核心算法,供64轮
    void exchange()
    {                

      a=A;b=B;c=C;d=D;
      /**//* Round 1 */
      FF (a, b, c, d, x[ 0],  7, 0xd76aa478); /**//* 1 */
      FF (d, a, b, c, x[ 1], 12, 0xe8c7b756); /**//* 2 */
      FF (c, d, a, b, x[ 2], 17, 0x242070db); /**//* 3 */
      FF (b, c, d, a, x[ 3], 22, 0xc1bdceee); /**//* 4 */
      FF (a, b, c, d, x[ 4],  7, 0xf57c0faf); /**//* 5 */
      FF (d, a, b, c, x[ 5], 12, 0x4787c62a); /**//* 6 */
      FF (c, d, a, b, x[ 6], 17, 0xa8304613); /**//* 7 */
      FF (b, c, d, a, x[ 7], 22, 0xfd469501); /**//* 8 */
      FF (a, b, c, d, x[ 8],  7, 0x698098d8); /**//* 9 */
      FF (d, a, b, c, x[ 9], 12, 0x8b44f7af); /**//* 10 */
      FF (c, d, a, b, x[10], 17, 0xffff5bb1); /**//* 11 */
      FF (b, c, d, a, x[11], 22, 0x895cd7be); /**//* 12 */
      FF (a, b, c, d, x[12],  7, 0x6b901122); /**//* 13 */
      FF (d, a, b, c, x[13], 12, 0xfd987193); /**//* 14 */
      FF (c, d, a, b, x[14], 17, 0xa679438e); /**//* 15 */
      FF (b, c, d, a, x[15], 22, 0x49b40821); /**//* 16 */

     /**//* Round 2 */
      GG (a, b, c, d, x[ 1],  5, 0xf61e2562); /**//* 17 */
      GG (d, a, b, c, x[ 6],  9, 0xc040b340); /**//* 18 */
      GG (c, d, a, b, x[11], 14, 0x265e5a51); /**//* 19 */
      GG (b, c, d, a, x[ 0], 20, 0xe9b6c7aa); /**//* 20 */
      GG (a, b, c, d, x[ 5],  5, 0xd62f105d); /**//* 21 */
      GG (d, a, b, c, x[10],  9, 0x02441453); /**//* 22 */
      GG (c, d, a, b, x[15], 14, 0xd8a1e681); /**//* 23 */
      GG (b, c, d, a, x[ 4], 20, 0xe7d3fbc8); /**//* 24 */
      GG (a, b, c, d, x[ 9],  5, 0x21e1cde6); /**//* 25 */
      GG (d, a, b, c, x[14],  9, 0xc33707d6); /**//* 26 */
      GG (c, d, a, b, x[ 3], 14, 0xf4d50d87); /**//* 27 */
      GG (b, c, d, a, x[ 8], 20, 0x455a14ed); /**//* 28 */
      GG (a, b, c, d, x[13],  5, 0xa9e3e905); /**//* 29 */
      GG (d, a, b, c, x[ 2],  9, 0xfcefa3f8); /**//* 30 */
      GG (c, d, a, b, x[ 7], 14, 0x676f02d9); /**//* 31 */
      GG (b, c, d, a, x[12], 20, 0x8d2a4c8a); /**//* 32 */

      /**//* Round 3 */
      HH (a, b, c, d, x[ 5],  4, 0xfffa3942); /**//* 33 */
      HH (d, a, b, c, x[ 8], 11, 0x8771f681); /**//* 34 */
      HH (c, d, a, b, x[11], 16, 0x6d9d6122); /**//* 35 */
      HH (b, c, d, a, x[14], 23, 0xfde5380c); /**//* 36 */
      HH (a, b, c, d, x[ 1],  4, 0xa4beea44); /**//* 37 */
      HH (d, a, b, c, x[ 4], 11, 0x4bdecfa9); /**//* 38 */
      HH (c, d, a, b, x[ 7], 16, 0xf6bb4b60); /**//* 39 */
      HH (b, c, d, a, x[10], 23, 0xbebfbc70); /**//* 40 */
      HH (a, b, c, d, x[13],  4, 0x289b7ec6); /**//* 41 */
      HH (d, a, b, c, x[ 0], 11, 0xeaa127fa); /**//* 42 */
      HH (c, d, a, b, x[ 3], 16, 0xd4ef3085); /**//* 43 */
      HH (b, c, d, a, x[ 6], 23, 0x04881d05); /**//* 44 */
      HH (a, b, c, d, x[ 9],  4, 0xd9d4d039); /**//* 45 */
      HH (d, a, b, c, x[12], 11, 0xe6db99e5); /**//* 46 */
      HH (c, d, a, b, x[15], 16, 0x1fa27cf8); /**//* 47 */
      HH (b, c, d, a, x[ 2], 23, 0xc4ac5665); /**//* 48 */

      /**//* Round 4 */
      II (a, b, c, d, x[ 0],  6, 0xf4292244); /**//* 49 */
      II (d, a, b, c, x[ 7], 10, 0x432aff97); /**//* 50 */
      II (c, d, a, b, x[14], 15, 0xab9423a7); /**//* 51 */
      II (b, c, d, a, x[ 5], 21, 0xfc93a039); /**//* 52 */
      II (a, b, c, d, x[12],  6, 0x655b59c3); /**//* 53 */
      II (d, a, b, c, x[ 3], 10, 0x8f0ccc92); /**//* 54 */
      II (c, d, a, b, x[10], 15, 0xffeff47d); /**//* 55 */
      II (b, c, d, a, x[ 1], 21, 0x85845dd1); /**//* 56 */
      II (a, b, c, d, x[ 8],  6, 0x6fa87e4f); /**//* 57 */
      II (d, a, b, c, x[15], 10, 0xfe2ce6e0); /**//* 58 */
      II (c, d, a, b, x[ 6], 15, 0xa3014314); /**//* 59 */
      II (b, c, d, a, x[13], 21, 0x4e0811a1); /**//* 60 */
      II (a, b, c, d, x[ 4],  6, 0xf7537e82); /**//* 61 */
      II (d, a, b, c, x[11], 10, 0xbd3af235); /**//* 62 */
      II (c, d, a, b, x[ 2], 15, 0x2ad7d2bb); /**//* 63 */
      II (b, c, d, a, x[ 9], 21, 0xeb86d391); /**//* 64 */

      A += a;
      B += b;
      C += c;
      D += d;

    }

    void md5(char strDest[33], const char *strSour)
    {
        assert( (strDest!=NULL) && (strSour != NULL));
        int i;
        ChangeToFile(strSour);
        fp=fopen(FileName,"rb");
        if(fp == NULL)
        {
            printf("can't open the temp file!/n");
            exit(0);
        }
        fseek(fp, 0, SEEK_END);  //文件指针转到文件末尾
        if((len=ftell(fp))==-1)
        {
            printf("Sorry! Can not calculate files which larger than 2 GB!/n");
            fclose(fp);
            exit(0);
        }  //ftell函数返回long,最大为2GB,超出返回-1
        rewind(fp);  //文件指针复位到文件头
        A=0x67452301,B=0xefcdab89,C=0x98badcfe,D=0x10325476; //初始化链接变量
        flen[1]=len/0x20000000;     //flen单位是bit
        flen[0]=(len%0x20000000)*8;
        memset(x,0,64);   //初始化x数组为0
        fread(&x,4,16,fp);  //以4字节为一组,读取16组数据
        for(i=0;i<len/64;i++)
        {    //循环运算直至文件结束
          exchange();
          memset(x,0,64);
          fread(&x,4,16,fp);
        }
        ((char*)x)[len%64]=128;  //文件结束补1,补0操作,128二进制即10000000
        if(len%64>55)
        {
            exchange();
            memset(x,0,64);
        }
        memcpy(x+14,flen,8);    //文件末尾加入原文件的bit长度
        exchange();
        fclose(fp);
        fp=fopen(FileName,"wr");
        fprintf(fp,"%08x",PP(A));
        fprintf(fp,"%08x",PP(B));
        fprintf(fp,"%08x",PP(C));
        fprintf(fp,"%08x",PP(D));
        fclose(fp);
        fp=fopen(FileName,"r");

        for(i=0;i<32;i++)
            strDest[i]=fgetc(fp);       
       
        strDest[i]='/0';
        fclose(fp);

       
    }
  5. 协议：不是按要求做的，只能说是个人力的浪费，就不说了
jasmine1987
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
为什么char类型最小值为-128？
weiyidemaomao的专栏
11-24 5168
[-1]补码 = 11111111 ？    -1 取绝对值 1     1 原码00000001     1 反码11111110    补码为反码+111111111     符号位置为111111111              依次类推，[-2]补码 = 11111110 [-3]补码 = 11111101 ... [-128]补码 = 10000000
ATAforecasting:R的ATAforecasting包-使用Ata方法的自动时间序列分析和预测
03-08
ATA预测 使用带有Box-Cox幂变换族和季节性分解技术的Ata方法进行自动时间序列分析和预测。 描述 ATA方法是一种新的替代性预测方法。 该方法替代了两种主要的预测方法：指数平滑法和ARIMA。 如Yapar，G.（2016） ，Yapar G.，Capar，S.，Selamlar，HT，Yavuz，I。（2017） 所述的基于修改后的简单指数平滑的Ata方法和Yapar G.，Selamlar，HT，Capar，S.，Yavuz，I.（2019） 是一种新的单变量时间序列预测方法，为解决在现有方法的初始化和优化阶段。 就易于实施和准确的预测而言，Ata方法的预测性能优于现有方法。 它可以应用于非季节性或季节性时间序列，该时间序列可以分解为四个部分（剩余，水平，趋势和季节性）。 该方法论在M3和M4竞赛数据上表现出色 安装 具有最新功能的开发版本： devtools::inst
c语言实现条件矩阵判断,C语言编程判断两个矩阵是否相等（n阶矩阵）
weixin_29887959的博客
05-25 1300
主要利用二维数组的模型来存储矩阵判断时一一比较，若有一对元素不相同，则矩阵不相同源代码：#include#includeint main(){int a[100][100], b[100][100];int n, i, m;printf("请输入要比较的矩阵行列数\n");scanf("%d", &n);printf("请输入第一个矩阵的元素\n");for (i = 0; i <=...
【转】linux libata初始化分析
weixin_30901729的博客
11-18 265
转自：http://zhangwenxin82.blog.163.com/blog/static/114595956201071934831530/ 进来分析libata模块，颇有所感，记录如下，希望能对大家有所帮助，同时也对自己的理解进一步深入。linux版本：linux-2.6.24.3注：因完全是个人理解，理解不当难免，恳请批评指正！！！！大家知道驱动程序在初始化sata controll...
AHCI驱动中的cmd
xyyangkun的专栏
07-08 2457
http://www.360doc.com/content/12/0801/17/5073814_227694747.shtml 这两天被AHCI控制器的驱动搞的焦头烂额，当然主要的问题其实不在软件，而是FPGA上的SATA物理层传输不够稳定，现在也没什么很好的办法。先写一下这两天看到的系统软件和AHCI控制器硬件交互的三个核心数据结构：cmd_slot / rx_fis / c
ATA接口VHDL源代码
09-06
总之，ATA接口VHDL源代码是硬件设计领域的一个重要实例，它涉及到接口设计、协议解析、数据传输优化等多个技术层面。通过深入研究这些源代码，不仅可以提升对ATA接口的理解，还能增强使用VHDL进行硬件设计的能力。
ATA-6总线协议源代码
05-20
ATA-6总线协议源代码 ATA100接口和数据线与ATA66一样，也是使用40针80芯的数据传输电缆，并且ATA100接口完全向下兼容，支持ATA33、ATA66接口的设备完全可以继续在ATA100接口中使用。ATA100规范可以轻松应付目前ATA...
ata.rar_ATA-7_ata
最新发布
09-20
在压缩包内的文件名"ata"可能是一个包含ATA-7规范细节的文档，或者是一个实现ATA-7协议的硬件描述语言（如Verilog或VHDL）代码。而"www.pudn.com.txt"可能是下载来源的注释或者是版权信息，通常这类文本文件会包含...
GPIF_USB-ATA
01-17
- **GPIFPROGRAM**：GPIF程序存储区，存储GPIF指令，可以存储四组波形的程序代码。 每个GPIF动作由七个阶段组成：Interval0至Interval6（简称I0至I6）。执行完I0至I6的动作后，进入IDLE（I7），即空闲状态，准备...
ata.rar_ata_visual c
09-14
在提供的"3.2.10 ata"文件中，可能包含了具体的源代码示例，这些示例通常会涵盖以上提到的各个部分，例如初始化函数、发送ATA命令的函数、读写扇区的函数以及错误处理函数等。通过学习和分析这些代码，你可以更直观...
技术岗笔试算法
weixin_44500533的博客
09-17 232
1,排序算法 空间复杂度最大：快速排序。
request到ATA cmd的转换过程
神恰以泽_CSDN
11-27 1204
原文地址：http://www.cnblogs.com/raymondpang/articles/4469500.html 1. 知识铺垫 　　据我所知（可能并不准确），Linux的存储系统基本上都已经被整合到SCSI存储框架之下，SAS自不必说，像SATA接口的设备（机械硬盘、SSD、光驱），USB设备都已经由SCSI框架管理，而NVMe虽然还未完全融入SCSI存储框架（Kernel 3.1...
ata驱动框架及scsi请求处理流程
神恰以泽_CSDN
11-27 2323
传统IDE-SCSI框架 这里所说的ATA Disk包含两大类：一类是传统的并行ATA（PATA），即IDE接口；另一类是目前流行的串行ATA（SATA）。对于IDE的驱动，Linux-2.6.28还进行了保留，其可以驱成传统的HD设备，也可以驱成流行的SD设备。对于SATA设备，Linux的标准做法是驱成SD设备，下面对传统ATA的驱动架构和目前流行ATA的驱动架构进行对比分析说明。 传统A...
使用硬盘ATA命令读取磁盘
wrmsr的专栏
03-31 5137
看网上也没有什么类似的代码,这里我就发一个,下面的程序是读取硬盘的第1个扇区! #include "stdafx.h" #include #include #include #define ULONG_PTR ULONG #include //SDK里面的头文件 using namespace std; int main(int argc, char* argv[]) { H
线性代数代码实现（三）矩阵的秩与可逆矩阵的判断（c++）
qq_54434938的博客
10-18 3076
前言： 之前介绍了如何将一个矩阵化成上三角矩阵，并且提到了矩阵的秩可以通过上三角矩阵轻松得出，秩就是上三角矩阵中非零行的个数，不知道怎么将一个矩阵通过初等行变换的伙伴们可以参考我的上一篇文章 ...
论文那些事—Boosting the Transferability of Adversarial Samples via Attention
shuweishuwei的博客
12-07 2445
Boosting the Transferability of Adversarial Samples via Attention（CVPR2020，ATA） 1、摘要 本文主要以提高对抗样本的迁移性为目的，黑盒攻击在真实情况中才最常发生。首先关于注意力机制，粗略的描述就是“你正在做什么，你就将注意力集中在那一点上”。本文也是首次将注意力机制运用在对抗样本上，注意力主要由反向传播的梯度构成。 本文贡献主要有三个： 提出了一种新的策略来提高对抗性图像的可转移性。它的特点是引入模型注意来正则化对抗噪
MTK 平台lcm驱动框架分析1
yqj2011的专栏
03-09 4823
源码路径：              kernel-3.18/arch/arm/boot/dts/mt6580.dtsi               kernel-3.18/drivers/misc/mediatek/video/common/mtkfb.c              kernel-3.18/drivers/misc/mediatek/video/mt6580/primary
ATA笔记
AI_盲的博客
02-02 1224
One Model to Serve ALL：多场景下的星型CTR预估模型STAR 解决问题 一些场景较小，数据量也比较少，这对复杂CTR模型的学习带来困难。对于数据量少难以拟合的问题，常见的做法是复用大场景的模型，比如首猜或者购后的模型来进行服务。但是这样做没有充分利用本场景数据，造成CTR预估准度不足。 为每个场景都单独维护一个模型。由于我们的场景数非常多，每个场景维护独立的模型会对系统资源和人力成本带来巨大的压力和挑战。 网络结构 参数共享 Scenario-Specific FCN
Java ATA证书考试关键知识点汇总
本文档提供了一些关于ATA（American Technical Association，美国技术协会）证书考试的相关题目，主要集中在Java编程的基础知识上。首先，讨论了Java程序开发周期，包括编译、下载、解释和执行四个阶段（A、B、C、D...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值