在本文中，我们将带你了解密钥导出函数在这篇文章中，我们将为您详细介绍密钥导出函数的方方面面，并解答Keyderivationfunction常见的疑惑，同时我们还将给您一些技巧，以帮助您实现更有效的2
在本文中，我们将带你了解密钥导出函数在这篇文章中，我们将为您详细介绍密钥导出函数的方方面面，并解答Key derivation function常见的疑惑，同时我们还将给您一些技巧，以帮助您实现更有效的203_PyTorch 中文教程：激活函数 - activation function、C ++ 类 | 类与函数（Function）_5、c++builder导出函数export function DLL、C语言学习笔记之函数（Function）。
本文目录一览：- 密钥导出函数（Key derivation function）（密钥导出函数）
- 203_PyTorch 中文教程：激活函数 - activation function
- C ++ 类 | 类与函数（Function）_5
- c++builder导出函数export function DLL
- C语言学习笔记之函数（Function）
密钥导出函数（Key derivation function）（密钥导出函数）
在密码学中，密钥导出函数（KDF）使用伪随机函数从秘密值（eg.主密钥）导出一个或多个密钥。KDF可用于将密钥扩展到更长的密钥或获得所需格式的密钥（eg.将作为Diffie-Hellman密钥交换的结果的组元素转换为用于AES的对称密钥）。密钥加密哈希函数是用于密钥推导的伪随机函数的流行示例。
KDFs的使用：
密钥导出函数通常与非秘密参数一起使用，以从公共秘密值导出一个或多个密钥。这样的使用可以防止获得派生密钥的攻击者学习关于输入秘密值或任何其他导出密钥的有用信息；也可以使用KDF来确保派生密钥具有其他期望的属性，诸如在某些特定加密系统中避免“弱密钥”。
KDFs最常见的用途是将密码散列的方法来密码验证，我们将非秘密参数称之为salt。KDFs也通常用作多方密钥协商协议的组成部分，这些关键推导函数的示例包括KDF1和ANSI X9.42中的类似功能。特别的，基于HMAC的提取和扩展密钥导出功能（HKDF） 是一种简单的基于HMAC的KDF，可用作各种协议和应用程序中的构建块。
我们下面针对密钥延伸（key stretching）对KDF进行下一步的描述：
KDF也用于从秘密密码或密码短语导出密钥的应用程序，密码通常不具有直接用作加密密钥的所需属性。在这样的应用中，通常建议将密钥导出功能故意缓慢，以阻止对密码或密码输入值的暴力攻击或字典攻击。
这种使用可以表示为DK = KDF（Key，Salt，Iterations），其中DK是派生密钥，KDF是密钥导出函数，Key是原始密钥或密码，Salt是作为密码盐的随机数，Iterations是指子功能的迭代次数。使用派生密钥代替原始密钥或密码作为系统的密钥。盐的值和迭代次数（如果不固定）与散列密码一起存储或以加密消息的明文形式发送。
暴力攻击的难度随着迭代次数的增加而增加。迭代计数的实际限制是用户不愿容忍登录计算机或看到解密消息的可察觉延迟。使用salt可以防止攻击者预先计算派生密钥的字典。
类似的，当下还有另一种方法叫做密钥强化（key strengthening），使用随机盐扩展键，但是不像密钥延伸一样可以安全地删除salt。这将强制攻击者和合法用户对salt值执行强力搜索。
---------------------
作者：sjrGCkym
来源：CSDN
原文：https://blog.csdn.net/sjrgckym/article/details/78195845
版权声明：本文为博主原创文章，转载请附上博文链接！
PBKDF2
编辑P 口令，一字节串
S 盐值，字节串
203_PyTorch 中文教程：激活函数 - activation function
203_PyTorch 中文教程：激活函数 - activation function
激活函数（activation function）在深度学习模型中起到基础变换函数的作用，与参数和网络层共同构成深度学习的神经网络模型。
- 更多参考: https://morvanzhou.github.io/tutorials/
- 油管频道: https://www.youtube.com/user/MorvanZhou
依赖软件包
- torch
import torch
import torch.nn.functional as F
from torch.autograd import Variable
import matplotlib.pyplot as plt
首先，创建一些虚拟的测试数据。
x = torch.linspace(-5, 5, 200) # x data (tensor), shape=(200, 1)
x = Variable(x)
x_np = x.data.numpy() # numpy array for plotting
x
tensor([-5.0000, -4.9497, -4.8995, -4.8492, -4.7990, -4.7487, -4.6985, -4.6482,
-4.5980, -4.5477, -4.4975, -4.4472, -4.3970, -4.3467, -4.2965, -4.2462,
-4.1960, -4.1457, -4.0955, -4.0452, -3.9950, -3.9447, -3.8945, -3.8442,
-3.7940, -3.7437, -3.6935, -3.6432, -3.5930, -3.5427, -3.4925, -3.4422,
-3.3920, -3.3417, -3.2915, -3.2412, -3.1910, -3.1407, -3.0905, -3.0402,
-2.9899, -2.9397, -2.8894, -2.8392, -2.7889, -2.7387, -2.6884, -2.6382,
-2.5879, -2.5377, -2.4874, -2.4372, -2.3869, -2.3367, -2.2864, -2.2362,
-2.1859, -2.1357, -2.0854, -2.0352, -1.9849, -1.9347, -1.8844, -1.8342,
-1.7839, -1.7337, -1.6834, -1.6332, -1.5829, -1.5327, -1.4824, -1.4322,
-1.3819, -1.3317, -1.2814, -1.2312, -1.1809, -1.1307, -1.0804, -1.0302,
-0.9799, -0.9296, -0.8794, -0.8291, -0.7789, -0.7286, -0.6784, -0.6281,
-0.5779, -0.5276, -0.4774, -0.4271, -0.3769, -0.3266, -0.2764, -0.2261,
-0.1759, -0.1256, -0.0754, -0.0251, 0.0251, 0.0754, 0.1256, 0.1759,
0.2261, 0.2764, 0.3266, 0.3769, 0.4271, 0.4774, 0.5276, 0.5779,
0.6281, 0.6784, 0.7286, 0.7789, 0.8291, 0.8794, 0.9296, 0.9799,
1.0302, 1.0804, 1.1307, 1.1809, 1.2312, 1.2814, 1.3317, 1.3819,
1.4322, 1.4824, 1.5327, 1.5829, 1.6332, 1.6834, 1.7337, 1.7839,
1.8342, 1.8844, 1.9347, 1.9849, 2.0352, 2.0854, 2.1357, 2.1859,
2.2362, 2.2864, 2.3367, 2.3869, 2.4372, 2.4874, 2.5377, 2.5879,
2.6382, 2.6884, 2.7387, 2.7889, 2.8392, 2.8894, 2.9397, 2.9899,
3.0402, 3.0905, 3.1407, 3.1910, 3.2412, 3.2915, 3.3417, 3.3920,
3.4422, 3.4925, 3.5427, 3.5930, 3.6432, 3.6935, 3.7437, 3.7940,
3.8442, 3.8945, 3.9447, 3.9950, 4.0452, 4.0955, 4.1457, 4.1960,
4.2462, 4.2965, 4.3467, 4.3970, 4.4472, 4.4975, 4.5477, 4.5980,
4.6482, 4.6985, 4.7487, 4.7990, 4.8492, 4.8995, 4.9497, 5.0000])
下面是几个流行的激活函数（activation functions）
y_relu = F.relu(x).data.numpy()
y_sigmoid = torch.sigmoid(x).data.numpy()
y_tanh = torch.tanh(x).data.numpy()
y_softplus = F.softplus(x).data.numpy()
# y_softmax = F.softmax(x)
# softmax is a special kind of activation function, it is about probability
# and will make the sum as 1.
绘制激活函数（activation function）响应曲线图。
%matplotlib inline
plt.figure(1, figsize=(8, 6))
plt.subplot(221)
plt.plot(x_np, y_relu, c=''red'', label=''relu'')
plt.ylim((-1, 5))
plt.legend(loc=''best'')
plt.subplot(222)
plt.plot(x_np, y_sigmoid, c=''red'', label=''sigmoid'')
plt.ylim((-0.2, 1.2))
plt.legend(loc=''best'')
plt.subplot(223)
plt.plot(x_np, y_tanh, c=''red'', label=''tanh'')
plt.ylim((-1.2, 1.2))
plt.legend(loc=''best'')
plt.subplot(224)
plt.plot(x_np, y_softplus, c=''red'', label=''softplus'')
plt.ylim((-0.2, 6))
plt.legend(loc=''best'')
plt.show()
显示输出如下：
C ++ 类 | 类与函数（Function）_5
类与函数的例子
我喜欢看代码（当然有必要我也会写），所以我会直接上码，找出一些关键点来分析：
class Student
{
public:
int studentID;
int grades[10];
void setStudentID(int inID)
{
studentID = inID;
}
int getStudentID()
{
return studentID;
}
void setGrade(int gradeNumber, int gradeIn)
{
grades[gradeNumber] = gradeIn;
}
int * getGrades()
{
return grades;
}
int getGrade(int gradeNumber)
{
return grades[gradeNumber];
}
void printGrades()
{
std::cout<<"StudentID = "<<studentID<<"\n";
for(int i = 0; i < 10; i++)
{
std::cout<<"\t"<<grades[i]<<"\n";
}
}
int sortGrades()
{
//sort ascending
for(int i = 0; i < 10; i++)
{
for(int j = 0; j < 9 - i; j++)
{
if(grades[j] > grades[j + 1])
{
int temp;
temp=grades[j];
grades[j]=grades[j + 1];
grades[j + 1]=temp;
}
}
}
}
int getMin()
{
sortGrades();
//std::cout<<"in class min"<<grades[0];
return grades[9];
}
int getMax()
{
sortGrades();
//std::cout<<"in class max"<<grades[9];
return grades[0];
}
float getAverageGrade()
{
float sum = 0;
for(int i = 0; i<10; i++)
{
sum = sum + grades[i];
}
return sum/10;
}
};
//********************
class CourseEnrollment
{
public:
Student students[6];
int courseMinGrade;
int courseMaxGrade;
float courseAvgGrade;
int grades[60];
void addStudents(Student* studentIn) //Student*表示类的指针??????????
{
for(int i = 0;i<6;i++)
{
students[i] = studentIn[i];
}
}
int * getAllGrades()
{
//int grades[60];
int k = 0;
for(int i = 0; i<6;i++)
{
for(int j = 0; j<10;j++)
{
grades[k] = students[i].getGrade(j);
k = k + 1;
}
}
return grades;
}
int * sortAllGrades()
{
for(int i = 0; i < 60; i++)
{
for(int j = 0; j < 59 - i; j++)
{
if(grades[j] > grades[j + 1])
{
int temp;
temp=grades[j];
grades[j]=grades[j + 1];
grades[j + 1]=temp;
}
}
}
return grades;
}
int getMinGrade()
{
sortAllGrades();
return grades[0];
}
int getMaxGrade()
{
sortAllGrades();
return grades[59];
}
float getAvgGrade()
{
int sum = 0;
for(int i=0;i<60;i++)
{
sum = sum + grades[i];
}
return sum/60;
}
void printAllGrades()
{
for(int i=0;i<60;i++)
{
std::cout<<"grade="<<grades[i]<<"\n";
}
}
};以上代码保存在头文件main.hpp。
#include <iostream>
#include <stdio.h>
#include "main.h"
const int CLASS_SIZE = 6;
int main()
{
Student studentsInClass[CLASS_SIZE];
CourseEnrollment course1;
static int studentNumber = 1000; ？
int grade;
int userInput;
//asign student id to each student
for(int i = 0; i < CLASS_SIZE; i++)
{
studentsInClass[i].setStudentID(studentNumber);
studentNumber++;
}
//for(int i = 0; i < CLASS_SIZE; i++)
//{
// std::cout<<"student #"<<i<<" has studentID #"<<studentsInClass[i].getStudentID()<<"\n\n";
//}
//assign grades to all students
for(int i = 0; i <CLASS_SIZE; i++)
{
for(int j = 0; j <10 ; j++)
{
scanf("%d", &grade);
studentsInClass[i].setGrade(j,grade);
}
}
//print out all students grades
for(int i = 0; i < CLASS_SIZE; i++)
{
studentsInClass[i].printGrades();
std::cout<<"\nMin grade = "<<studentsInClass[i].getMin()<<"\n";
std::cout<<"Max grade = "<<studentsInClass[i].getMax()<<"\n";
std::cout<<"Grade Average = "<<studentsInClass[i].getAverageGrade()<<"\n\n";
}
course1.addStudents(studentsInClass);
int *allGrades;
allGrades = course1.getAllGrades();
allGrades = course1.sortAllGrades();
std::cout<<"ALLGRADES\n";
std::cout<<"Lowest grade for entire course = "<<course1.getMinGrade()<<"\n";
std::cout<<"Highest grade for entire course = "<<course1.getMaxGrade()<<"\n";
std::cout<<"Avg grade for entire course = "<<course1.getAvgGrade()<<"\n";
return 0;
}运行输入：
91 92 85 58 87 75 89 97 79 65
88 72 81 94 90 61 72 75 68 77
75 49 87 79 65 64 62 51 44 70
81 72 85 78 77 75 79 87 69 55
88 62 71 74 80 71 62 85 68 87
75 89 97 79 65 48 72 61 64 90
运行结果：
代码解析：
1、
int * getGrades()
{
return grades;
}为什么这个 Student类 下面getGrades()函数（即方法），前面加个 " * " 呢？
答：这个 " * " 号 不和 函数 连在一起的，是函数返回值的一部分，表示子程序返回来的是指针类型。例如：
struct student *insert(struct student *head) 这个函数的返回值就是，struct student * 。
看了上面的例子，你可能又会问 struct 是什么？
答：struct 定义了一个结构体类型。例如：
struct Point {
int x;
int y;
};定义了一个结构体类型 Point ，声明变量时直接 Point p1; 。p1 是一个结构体变量 。
在 C中，struct 不能包含函数 ；
在C++中，对 struct 进行了扩展，可以包含函数；
在C++中，之所以包含两种定义方式，主要是为了兼容 C语言；这里通常也会使用一个函数 typedef ：
typedef struct Point {
int x;
int y;
}声明变量类型时，直接 Point p2; ， 所以 typedef struct Point{}，p2是一个结构体类型。
2、
int sortGrades()
{
//sort ascending
for(int i = 0; i < 10; i++)
{
for(int j = 0; j < 9 - i; j++)
{
if(grades[j] > grades[j + 1])
{
int temp;
temp=grades[j];
grades[j]=grades[j + 1];
grades[j + 1]=temp;
}
}
}
}这段程序大有来头，就是出自我们的经典排序算法——冒泡排序。
没错，他就是对顺序混乱的一堆数字，使用前后两个值比较，决定谁放在前面，谁放在后面，如果从左边开始比较，经过第一轮排序后，最大值的数字肯定在数组的末尾位置。否则，从右边开始比较的话，经过一轮的排序，最小值肯定在数组的第一个位置。所以，经过第一轮排序后，就会少一个位置无须再比较了，这里使用的 双for 循环语句 就是为了这个效果。
注意 for(j=0; j<9-i; j++)，这里的 j < 9 - i; 就是控制其中的。
3、
c++builder导出函数export function DLL
__stdcall __export 即可，如：
ulong __stdcall __export od_disasm(char *src,ulong srcsize,ulong srcip,
t_disasm *disasm,int disasmmode)
{
return Disasm(src,srcsize,srcip,disasm,disasmmode);
}
C语言学习笔记之函数（Function）
C语言的函数：
一、定义函数
return_type function_name(parameter list)
{
body of the function
}
二、调用函数
2.1函数参数
如果函数要使用参数，则必须声明接受参数值的变量。这些变量称为函数的形式参数。
2.2两种参数传递的方法
①传值方式调用函数:
向函数传递参数的传值调用，把参数的实际值复制给函数的形式参数在这种情况下，修改函数内的形式参数将不会影响实际参数。
1 #include <stdio.h>
2 void swap(int x,int y);
3 int main()
4 {
5 int a=100;
6 int b=200;
7
8 swap(a,b);
9 }
10 void swap(int x,int y)
11 {
12 int temp;
13 temp=x;
14 x=y;
15 y=temp;
16 }②引用方式调用函数：
通过引用传递方式，形参为指向实参的地址，当对形参的指向操作时，就相当于对实参本身进行的操作。
传递指针可以让多个函数访问指针所引用的对象，而不用把对象声明为全局可访问。
1 void swap(int *x,int *y)
2 {
3 int temp;
4 temp=*x;
5 *x=*y;
6 *y=temp;
7
8 return;
9 }
10
11 # include <stdio.h>
12 int main()
13 {
14 int a=100;
15 int b=200;
16
17 p交换前a的值
18 p交换前b的值
19
20 //调用函数来交换值
21 //&a表示指向a的指针，即变量a的地址
22 //
23
24 swap(&a,&b);
25
26 p交换后a的地址
27 p交换后b的地址
28
29 return 0;
30 }整理自菜鸟教程 https://www.runoob.com
关于密钥导出函数和Key derivation function的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于203_PyTorch 中文教程：激活函数 - activation function、C ++ 类 | 类与函数（Function）_5、c++builder导出函数export function DLL、C语言学习笔记之函数（Function）的相关知识，请在本站寻找。
本文标签：
