么 要耐得住寂寞 当然学习过程枯燥 如果你有那么会支持你学下去 如果学习的话 推荐你一个学习过程：

　　1.学习汇编

　　2.会用VC等编程工具编程 也就是会一些编程语言

　　3.熟悉PE格式 这个很重要 因为一般免杀 加壳 脱壳 都需要

　　4.对于入侵网站那些东西自己网上看看手动注入教程就行 很容易上手

　　当你这些都很精通后 可以学习调试程序 或者微软漏洞调试 自己写EXPLOIT

　　总之 过程很痛苦 但当你一个一个攻克了就会感觉很兴奋 想当年我做免杀在梦里都在做 呵呵

　　PS：本人玩黑N年了

　　基础你扎实不？ 真想学2113个5261黑客群 西不是说学会4102就会的，是需要下真功夫的。我1653也想学，但是需要懂的要多太多了 后来放弃了 我去吃饭不多说了 总之一句话 要想学好 一定要下到足够的决心 加个黑客的群 百度能搜出来 *** 哪也能

　　msf一把梭

　　学编程，学web，学脚本，学逆向。学协议，学底层，打打pwn，挖挖洞。啥玩儿咋还顺起口了呢。还有那个……我也是小白

　　你还是先确定自己要学哪一个安全领域，对哪一个领域感兴趣 （二进制、Web、区块链、移动、工控等等）

　　黑客，我觉得是种荣誉

　　技术、技能，只有在你确定了自己的方向后，再去专攻学习，要不然东学一点西学一点，不止学的杂，还会降低学习的欲望

　　不要局限于国内，不要局限于中文，一步成神是在梦里，三十天速成的是骗局，他说过终归是他说的，你要做做看，搜索引擎不是摆设，不懂就问改成不懂就查

　　

　　编程学着走吧，推荐c和python，然后web安全，你去看看学习的流程图，或者找个师傅带

　　想要成为黑客，要学的东西有很多很多

　　简单罗列一些基本的吧

　　1、SQL注入

　　了解SQL注入发生原理，熟悉掌握sqlmap工具，学会手工注入

　　2、暴力破解

　　懂得利用burpsuite等软件进行暴力破解

　　3、XSS

　　学会XSS三种攻击方式：反射型、存储型、dom型

　　4、文件上传

　　了解文件上传漏洞产生的几种方式：IIS解析漏洞、Apache解析漏洞、PHP CGI 解析漏洞、 *** 本地验证绕过、MIME类型检测、服务端检测绕过、截断绕过、白名单绕过

　　5、文件包含

　　本地文件包含、远程文件包含、伪协议

　　6、扫描

　　学会利用工具扫描网站漏洞、扫描网站目录、扫描c段、服务器开放端口、扫描出二级域名

　　7、信息收集

　　学会收集站点信息（网站语言、编码、敏感文件、架构）、服务器信息（操作系统、环境版本）、个人信息、懂得利用百度谷歌收集数据。

　　8、kali系统

　　学会利用kali系统上的功能，东西太多就不打出来了，看图。

　　

　　你需要学的东西有很多很多，更好先从自己的兴趣出发，这样你能有成就感，不会枯燥

　　当然了，更好找一个水平高的大神带你走，这样你学起来会快很多很多

　　10年技术积累，感兴趣的可以跟我来学

　　我这里有很多的干货资料

　　

　　有需要可以参考下图找我交流

　　

　　"""

　　Linear Discriminant Analysis

　　Assumptions About Data :

　　1. The input variables has a gaussian distribution.

　　2. The variance calculated for each input variables by class grouping is the

　　same.

　　3. The mix of classes in your training set is representative of the problem.

　　Learning The Model :

　　The LDA model requires the estimation of statistics from the training data :

　　1. Mean of each input value for each class.

　　2. Probability of an instance belong to each class.

　　3. Covariance for the input data for each class

　　Calculate the class means :

　　mean(x)=1/n ( for i=1 to i=n --> sum(xi))

　　Calculate the class probabilities :

　　P(y=0)=count(y=0) / (count(y=0) + count(y=1))

　　P(y=1)=count(y=1) / (count(y=0) + count(y=1))

　　Calculate the variance :

　　We can calculate the variance for dataset in two steps :

　　1. Calculate the squared difference for each input variable from the

　　group mean.

　　2. Calculate the mean of the squared difference.

　　------------------------------------------------

　　Squared_Difference=(x - mean(k)) ** 2

　　Variance=(1 / (count(x) - count(classes))) *

　　(for i=1 to i=n --> sum(Squared_Difference(xi)))

　　Making Predictions :

　　discriminant(x)=x * (mean / variance) -

　　((mean ** 2) / (2 * variance)) + Ln(probability)

　　---------------------------------------------------------------------------

　　After calculating the discriminant value for each class, the class with the

　　largest discriminant value is taken as the prediction.

　　Author: @EverLookNeverSee

　　"""

　　from math import log

　　from os import name, system

　　from random import gauss

　　from random import seed

　　# Make a training dataset drawn from a gaussian distribution

　　def gaussian_distribution(mean: float, std_dev: float, instance_count: int) -> list:

　　"""

　　Generate gaussian distribution instances based-on given mean and standard deviation

　　:param mean: mean value of class

　　:param std_dev: value of standard deviation entered by usr or default value of it

　　:param instance_count: instance number of class

　　:return: a list containing generated values based-on given mean, std_dev and

　　instance_count

　　>>> gaussian_distribution(5.0, 1.0, 20) # doctest: +NORMALIZE_WHITESPACE

　　[6.288184753155463, 6.4494456086997705, 5.066335808938262, 4.235456349028368,

　　3.9078267848958586, 5.031334516831717, 3.977896829989127, 3.56317055489747,

　　5.199311976483754, 5.133374604658605, 5.546468300338232, 4.086029056264687,

　　5.005005283626573, 4.935258239627312, 3.494170998739258, 5.537997178661033,

　　5.320711100998849, 7.3891120432406865, 5.202969177309964, 4.855297691835079]

　　"""

　　seed(1)

　　return[gauss(mean, std_dev) for _ in range(instance_count)]

　　# Make corresponding Y flags to detecting classes

　　def y_generator(class_count: int, instance_count: list) -> list:

　　"""

　　Generate y values for corresponding classes

　　:param class_count: Number of classes(data groupings) in dataset

　　:param instance_count: number of instances in class

　　:return: corresponding values for data groupings in dataset

　　>>> y_generator(1,[10])

　　[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

　　>>> y_generator(2,[5, 10])

　　[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

　　>>> y_generator(4,[10, 5, 15, 20]) # doctest: +NORMALIZE_WHITESPACE

　　[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

　　2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]

　　"""

　　return[k for k in range(class_count) for _ in range(instance_count[k])]

　　# Calculate the class means

　　def calculate_mean(instance_count: int, items: list) -> float:

　　"""

　　Calculate given class mean

　　:param instance_count: Number of instances in class

　　:param items: items that related to specific class(data grouping)

　　:return: calculated actual mean of considered class

　　>>> items=gaussian_distribution(5.0, 1.0, 20)

　　>>> calculate_mean(len(items), items)

　　5.011267842911003

　　"""

　　# the sum of all items divided by number of instances

　　return sum(items) / instance_count

　　# Calculate the class probabilities

　　def calculate_probabilities(instance_count: int, total_count: int) -> float:

　　"""

　　Calculate the probability that a given instance will belong to which class

　　:param instance_count: number of instances in class

　　:param total_count: the number of all instances

　　:return: value of probability for considered class

　　>>> calculate_probabilities(20, 60)

　　0.3333333333333333

　　>>> calculate_probabilities(30, 100)

　　0.3

　　"""

　　# number of instances in specific class divided by number of all instances

　　return instance_count / total_count

　　# Calculate the variance

　　def calculate_variance(items: list, means: list, total_count: int) -> float:

　　"""

　　Calculate the variance

　　:param items: a list containing all items(gaussian distribution of all classes)

　　:param means: a list containing real mean values of each class

　　:param total_count: the number of all instances

　　:return: calculated variance for considered dataset

　　>>> items=gaussian_distribution(5.0, 1.0, 20)

　　>>> means=[5.011267842911003]

　　>>> total_count=20

　　>>> calculate_variance([items], means, total_count)

　　0.9618530973487491

　　"""

　　squared_diff=[]# An empty list to store all squared differences

　　# iterate over number of elements in items

　　for i in range(len(items)):

　　# for loop iterates over number of elements in inner layer of items

　　for j in range(len(items[i])):

　　# appending squared differences to 'squared_diff' list

　　squared_diff.append((items[i][j]- means[i]) ** 2)

　　# one divided by (the number of all instances - number of classes) multiplied by

　　# sum of all squared differences

　　n_classes=len(means) # Number of classes in dataset

　　return 1 / (total_count - n_classes) * sum(squared_diff)

　　# Making predictions

　　def predict_y_values(

　　x_items: list, means: list, variance: float, probabilities: list

　　) -> list:

　　""" This function predicts new indexes(groups for our data)

　　:param x_items: a list containing all items(gaussian distribution of all classes)

　　:param means: a list containing real mean values of each class

　　:param variance: calculated value of variance by calculate_variance function

　　:param probabilities: a list containing all probabilities of classes

　　:return: a list containing predicted Y values

　　>>> x_items=[[6.288184753155463, 6.4494456086997705, 5.066335808938262,

　　... 4.235456349028368, 3.9078267848958586, 5.031334516831717,

　　... 3.977896829989127, 3.56317055489747, 5.199311976483754,

　　... 5.133374604658605, 5.546468300338232, 4.086029056264687,

　　... 5.005005283626573, 4.935258239627312, 3.494170998739258,

　　... 5.537997178661033, 5.320711100998849, 7.3891120432406865,

　　... 5.202969177309964, 4.855297691835079],[11.288184753155463,

　　... 11.44944560869977, 10.066335808938263, 9.235456349028368,

　　... 8.907826784895859, 10.031334516831716, 8.977896829989128,

　　... 8.56317055489747, 10.199311976483754, 10.133374604658606,

　　... 10.546468300338232, 9.086029056264687, 10.005005283626572,

　　... 9.935258239627313, 8.494170998739259, 10.537997178661033,

　　... 10.320711100998848, 12.389112043240686, 10.202969177309964,

　　... 9.85529769183508],[16.288184753155463, 16.449445608699772,

　　... 15.066335808938263, 14.235456349028368, 13.907826784895859,

　　... 15.031334516831716, 13.977896829989128, 13.56317055489747,

　　... 15.199311976483754, 15.133374604658606, 15.546468300338232,

　　... 14.086029056264687, 15.005005283626572, 14.935258239627313,

　　... 13.494170998739259, 15.537997178661033, 15.320711100998848,

　　... 17.389112043240686, 15.202969177309964, 14.85529769183508]]

　　>>> means=[5.011267842911003, 10.011267842911003, 15.011267842911002]

　　>>> variance=0.9618530973487494

　　>>> probabilities=[0.3333333333333333, 0.3333333333333333, 0.3333333333333333]

　　>>> predict_y_values(x_items, means, variance, probabilities) # doctest: +NORMALIZE_WHITESPACE

　　[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,

　　1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

　　2, 2, 2, 2, 2, 2, 2, 2, 2]

　　"""

　　# An empty list to store generated discriminant values of all items in dataset for

　　# each class

　　results=[]

　　# for loop iterates over number of elements in list

　　for i in range(len(x_items)):

　　# for loop iterates over number of inner items of each element

　　for j in range(len(x_items[i])):

　　temp=[]# to store all discriminant values of each item as a list

　　# for loop iterates over number of classes we have in our dataset

　　for k in range(len(x_items)):

　　# appending values of discriminants for each class to 'temp' list

　　temp.append(

　　x_items[i][j]* (means[k]/ variance)

　　- (means[k]** 2 / (2 * variance))

　　+ log(probabilities[k])

　　)

　　# appending discriminant values of each item to 'results' list

　　results.append(temp)

　　return[l.index(max(l)) for l in results]

　　# Calculating Accuracy

　　def accuracy(actual_y: list, predicted_y: list) -> float:

　　"""

　　Calculate the value of accuracy based-on predictions

　　:param actual_y:a list containing initial Y values generated by 'y_generator'

　　function

　　:param predicted_y: a list containing predicted Y values generated by

　　'predict_y_values' function

　　:return: percentage of accuracy

　　>>> actual_y=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,

　　... 1, 1 ,1 ,1 ,1 ,1 ,1]

　　>>> predicted_y=[0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0,

　　... 0, 0, 1, 1, 1, 0, 1, 1, 1]

　　>>> accuracy(actual_y, predicted_y)

　　50.0

　　>>> actual_y=[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,

　　... 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]

　　>>> predicted_y=[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,

　　... 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]

　　>>> accuracy(actual_y, predicted_y)

　　100.0

　　"""

　　# iterate over one element of each list at a time (zip mode)

　　# prediction is correct if actual Y value equals to predicted Y value

　　correct=sum(1 for i, j in zip(actual_y, predicted_y) if i==j)

　　# percentage of accuracy equals to number of correct predictions divided by number

　　# of all data and multiplied by 100

　　return (correct / len(actual_y)) * 100

　　我当初和样，满怀兴2113趣5261后搞了好几年，以为只要有决心就4102OK，可头来，学是学到一1653但是和当初想的根本不一样（基本没用）。而且学到的技术没用几天就废了（那根本不是技术，就是按葫芦画瓢），什么论坛什么的，当初很相信，报了两个会员，2000多，没学几天就跑路了。现在看看几年前的论坛，都转正了，现在已经没有所谓的黑客论坛了，站长信誉好不好没用，不转要抓进去的，要么封掉，什么VIP会员都是些视频加教程，讲师什么的偶尔给你说两次，不是打击你，我当初信心满满和家里人说要靠这个赚钱，亏了多少自己数不清，主要是精力，以前 *** 上加了一堆黑客朋友，现在头像全是黑的，偶尔碰到几个问问，都说不搞了，没精力。

　　论坛没用的（卡饭什么的除外，我几年学的到最后还是这种真宗的论坛好，不是所谓的安全网），学点语言是真的，但枯燥发味，我觉得当好一个黑客比高考考个一本难不知多少倍。

　　最后一句，玩玩没什么，什么培训死也不要，一分钱也不要，钱花了，精力耗尽了，到头想想玩这个的时间花在别的地方不知道可以做成什么了

　　我的真实经历，呵呵

　　百度搜索 梦想黑客联盟

　　百度搜索 梦想黑客联盟

　　放弃吧