修改当前用户的sudo超级用户权限&socks5代理访问网络

2013-01-22 10:37:54    

xx is not in the sudoers file 问题解决的两种方案如下。。。  

两种方法执行命令不同而已，原理其实一样

  www.2cto.com  

方法一：

首先利用whereis 命令查找sudoers配置文件的目录（默认会在etc/sudoers)

[root@localhost xiaofei]# whereis sudoers

sudoers: /etc/sudoers /etc/sudoers.bak /usr/share/man/man5/sudoers.5.gz

然后需要su -切换到root用户，更改/etc/sudoers的权限

[root@localhost xiaofei]# chmod u+w /etc/sudoers

然后就可以利用vi编辑器来把用户添加到sudoers之中：

[root@localhost xiaofei]# vi /etc/sudoers

然后找到root    ALL=(ALL)       ALL所在的位置，把所要添加的用户添加到文件之中，

下面是添加完的结果：

## Allow root to run any commands anywhere

root    ALL=(ALL)    ALL

xiaofei ALL=(ALL)     ALL （这一行是添加的内容，xiaofei是用户名）

然后需要把sudoers 的写权限去掉：

[root@localhost xiaofei]# chmod u-w /etc/sudoers

如果不去掉写权限，系统不允许执行suoders文件，运行sudo命令时会出现以下错误：

sudo: /etc/sudoers is mode 00, should be 0440                                 www.2cto.com  

至此，在退出root用户之后就可以利用sudo命令来执行超级用户的权限了。

方法二：

首需要切换到root身份

$su -

(注意有- ，这和su是不同的，在用命令"su"的时候只是切换到root，但没有把root的环境变量传过去，还是当前用户的环境变量，用"su -"命令将环境变量也一起带过去，就象和root登录一样)

然后

$visudo    //切记，此处没有vi和sudo之间没有空格

1、移动光标，到最后一行

2、按a，进入append模式

3、输入

your_user_name    ALL=(ALL)    ALL

4、按Esc

5、输入“:wq”

这样就把自己加入了sudo组，可以使用sudo命令了。

2》通过Socket5代理服务器访问网络的问题

时间:2010-11-20 15:39来源:未知 作者:admin 点击:次

通过Socket5代理服务器访问网络的问题Socks5版本的协议说明参考 RFC1928,RFC1929

下面简单地罗列程序实现，不涉及详细的协议规范。首先对于TCP连接，然后再讨论UDP传输。至于通过socks5的多播通讯，有兴趣可以参考D. Chouinard的文章。

1、TCP:

// 建立流套接字 

SOCKET m_socTCP=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

// 连接到代理服务器

int nRet = connect(m_socTCP,(SOCKADDR*)&m_saiProxy,sizeof(m_saiProxy));

// Step 1: 连接代理服务器成功后，马上开始和代理协商，协商报文如下,询问服务器，版本5，是需要验证(0x02)还是不需要验证(0x00)

　　+------+-------------------+------------+

　　|VER   | Number of METHODS | METHODS    |

　　+------+-------------------+------------+

　　| 0x05 | 0x02 (有两个方法)  | 0x00 | 0x02|

　　+------+-------------------+------------+

const char reqNego[4]={(char)0x05,(char)0x02,(char)0x00,(char)0x02};

nRet = send(m_socTCP,reqNego,4,0);

// Setp 2: 代理服务器将返回两个字节的协商结果，接收协商结果

fd_set fdread;FD_ZERO(&fdread);

FD_SET(m_socTCP,&fdread);

// Last param set to NULL for blocking operation. (struct timeval*)

if((nRet=select(0,&fdread,NULL,NULL,NULL))==SOCKET_ERROR){return NC_E_PROXY_SELECT_READ|WSAGetLastError();}

char resNego[2]={‘\\0‘};

int nRcvd=0,nCount=0;

while(1)

{

if(FD_ISSET(m_socTCP,&fdread))

{

//接收sock[0]发送来的数据

do{

nRet = recv(m_socTCP, (char*)resNego+nRcvd, 2-nRcvd,0);

if(nRet==SOCKET_ERROR){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

nRcvd += nRet;

}

while((nRcvd!=2)&&(++nCount<1000));

if(nRcvd==2) break;

}

if(nCount++>=2000){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

}

if(resNego[0]!=0x05 || (resNego[1]!=0x00 && resNego[1]!=0x02)){return NC_E_PROXY_PROTOCOL_VERSION|WSAGetLastError();};

// Step 3: 根据协商结果判断是否需要验证用户，如果是0x02，则需要提供验证，验证部分参考RFC1929

if(resNego[1]==0x02)

{

// 需要密码验证

char reqAuth[513]={‘\\0‘};

BYTE byLenUser = (BYTE)strlen(m_szProxyUserName);

BYTE byLenPswd = (BYTE)strlen(m_szProxyPassword);

reqAuth[0]=0x01;

reqAuth[1]=byLenUser;

sprintf(&reqAuth[2],"%s",m_szProxyUserName);

reqAuth[2+byLenUser]=byLenPswd;

sprintf(&reqAuth[3+byLenUser],"%s",m_szProxyPassword);

//Send authentication info

int len = (int)byLenUser + (int)byLenPswd + 3;

nRet=send(m_socTCP,(const char*)reqAuth,len,0);

if (nRet==SOCKET_ERROR){return NC_E_PROXY_SEND|WSAGetLastError();}

//Now : Response to the auth request

char resAuth[2]={‘\\0‘};

int nRcvd=0,nCount=0;

do{

nRet = recv(m_socTCP,resAuth+nRcvd,2-nRcvd,0);

if(nRet==SOCKET_ERROR){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

nRcvd += nRet;

}

while((nRcvd!=2)&&(++nCount<1000));

if(nCount>=1000){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

if (resAuth[1]!=0) return NC_E_PROXY_AUTHORIZE;

// 密码验证通过了

}

// Step 4: 协商完成，开始发送连接远程服务器请求,请求报文格式如下：

　　+----+-----+-------+------+----------+----------+

　　|VER | CMD |　RSV　| ATYP | DST.ADDR | DST.PORT |

　　+----+-----+-------+------+----------+----------+

　　| 1　| 　1 | 0x00  | 　1　| Variable |　　 2　　 |

　　+----+-----+-------+------+----------+----------+

// CMD==0x01 表示连接, ATYP==0x01表示采用IPV4格式地址，DST.ADDR是远程服务器地址，DST.PORT是远程服务器端口

// 如果需要接受外来连接，则需要在连接完成之后，发送CMD==0x02绑定请求，代理将为此请求绑定一个套接字接受外部连接

char reqSubNego[10]={(char)0x05,(char)0x01,(char)0x00,(char)0x01,(char)0x00,(char)0x00,(char)0x00,(char)0x00,(char)0x00,(char)0x00};

*(unsigned long*)&reqSubNego[4] =m_saiServerTCP.sin_addr.S_un.S_addr;

*(unsigned short*)&reqSubNego[8]=m_saiServerTCP.sin_port;

nRet=send(m_socTCP,(const char*)reqSubNego,10,0);

if (nRet==SOCKET_ERROR){return NC_E_PROXY_SEND|WSAGetLastError();}

// Step 5: 接收对请求的响应，响应包格式如下

　　+----+-----+-------+------+----------+----------+

　　|VER | REP |　RSV　| ATYP | BND.ADDR | BND.PORT |

　　+----+-----+-------+------+----------+----------+

　　| 1　|　1　| 0x00  |　1 　 | Variable | 　　2 　 |

　　+----+-----+-------+------+----------+----------+

// VER 必须是0x05, REP==0x00表示成功，ATYP==0x01表示地址是IPV4地址，BND.ADDR 是代理为连接远程服务器绑定的地址，BND.PORT是这个套接字的端口

char resSubNego1[5]={‘\\0‘};

if(FD_ISSET(m_socTCP,&fdread))

{

int nRcvd=0,nCount=0;

do{

nRet = recv(m_socTCP,resSubNego1+nRcvd,5-nRcvd,0);

if(nRet==SOCKET_ERROR){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

nRcvd += nRet;

}

while((nRcvd!=5)&&(++nCount<1000));

if(nCount>=1000){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

if(resSubNego1[0]!=0x05||resSubNego1[1]!=0x00){return NC_E_PROXY_PROTOCOL_VERSION_SUB|WSAGetLastError();};

switch(resSubNego1[3])

{

case 0x01:

{

// IP V4

char resSubNego2[6]={resSubNego1[4],0};

int nRet=-1;

if(FD_ISSET(m_socTCP,&fdread))

{

int nRcvd=0,nCount=0;

do{

int nRet = recv(m_socTCP,&resSubNego2[1]+nRcvd,5-nRcvd,0);

if(nRet==SOCKET_ERROR){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

nRcvd += nRet;

}

while((nRcvd!=5)&&(++nCount<1000));

if(nCount>=1000){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

}

// 得到代理绑定地址

unsigned long  ulBINDAddr = *(unsigned long*)&resSubNego2; // SOCKS BIND ADDR

unsigned short usBINDPort = *(unsigned short*)&resSubNego2[4]; // SOCKS BIND PORT

m_saiProxyBindTCP.sin_addr.S_un.S_addr=ulBINDAddr;

m_saiProxyBindTCP.sin_port=usBINDPort;

// 得到本机绑定地址

int len = sizeof(m_saiHostTCP);

getsockname(m_socTCP,(SOCKADDR*)&m_saiHostTCP,&len);

}

break;

case 0x03:

{

// Domain name

int nLen = resSubNego1[4]+2;

char* presSubNego2 = new char[nLen];

if(FD_ISSET(m_socTCP,&fdread))

{

int nRet=0,nRcvd=0,nCount=0;

do{

nRet = recv(m_socTCP,presSubNego2+nRcvd,nLen-nRcvd,0);

if(nRet==SOCKET_ERROR){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

nRcvd += nRet;

}

while((nRcvd!=nLen)&&(++nCount<1000));

if(nCount>=1000){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

}

unsigned short usBINDPort = *(unsigned short*)(presSubNego2+nLen-2); // BIND PORT;

// 此时得到的是远程主机的Domain Name

delete[] presSubNego2; presSubNego2=NULL;

}

break;

case 0x04:

{

// IPV6

AfxMessageBox("该版本不支持IPV6";

}

break;

default:

break;

}

// 至此，连接已经建立。在此套接字上可进行数据的收发。

}

2、UDP

SOCKS V5提供了对UDP的支持，它通过在代理服务器和内网主机之间建立一个UDP中继的TCP连接，来辅助进行UDP数据包的收发。此连接有一个有效期，在此 有效生命周期内，必须往代理发送UDP数据报确认连接有效，来维持此连接的有效性，否则，代理服务器超时，将会自动释放此连接的资源。

下面简单地罗列程序实现，不涉及详细的协议规范。

// 客户端为UDP中继建立一个相关的流套接字

SOCKET m_socClientTCP_UdpAssociate = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

// 连接代理服务器

int nRet=connect(m_socClientTCP_UdpAssociate,(SOCKADDR*)&saiProxy,sizeof(saiProxy));

// 连接成功，开始和代理服务器协商，首先发送版本标志，方法选择报文

const char reqNego[4]={(char)0x05,(char)0x02,(char)0x00,(char)0x02};

nRet = send(m_socClientTCP_UdpAssociate,reqNego,4,0);

if( nRet==SOCKET_ERROR 

{

DWORD dwError = WSAGetLastError();

if (dwError!=WSAEWOULDBLOCK) return NCM_E_WM_CREATE_PROXYREQUESTFAILED;

}

// 接收协商的响应

fd_set fdread; FD_ZERO(&fdread);

FD_SET(m_socClientTCP_UdpAssociate,&fdread);

if((nRet=select(0,&fdread,NULL,NULL,NULL))==SOCKET_ERROR) return NCM_E_WM_CREATE_PROXYCONNECTFAILED;

char resNego[2]={0};

int nRcvd=0,nCount=0;

if(FD_ISSET(m_socClientTCP_UdpAssociate,&fdread))

{

nRcvd = recv(m_socClientTCP_UdpAssociate, (char*)resNego+nRcvd, 2,0);

if(nRcvd==SOCKET_ERROR) return NCM_E_WM_CREATE_PROXYCONNECTFAILED;

}

if(resNego[0]!=0x05 || (resNego[1]!=0x00 && resNego[1]!=0x02)) return NCM_E_WM_CREATE_PROXYCONNECTFAILED;

// 看是否需要密码验证

if(resNego[1]==0x02)

{

// 需要密码验证

char reqAuth[513]; memset(reqAuth,0,513);

BYTE byLenUser = (BYTE)strlen(m_szProxyUserName);

BYTE byLenPswd = (BYTE)strlen(m_szProxyPassword);

reqAuth[0]=0x01;

reqAuth[1]=byLenUser;

sprintf(&reqAuth[2],"%s",m_szProxyUserName);

reqAuth[2+byLenUser]=byLenPswd;

sprintf(&reqAuth[3+byLenUser],"%s",m_szProxyPassword);

//Send authentication info

int len = (int)byLenUser + (int)byLenPswd + 3;

int ret=send(m_socClientTCP_UdpAssociate,(const char*)reqAuth,len,0);

if (ret==SOCKET_ERROR) if (GetLastError()!=WSAEWOULDBLOCK) return NCM_E_WM_CREATE_PROXYREQUESTFAILED;

//Now : Response to the auth request

char resAuth[2]={‘\\0‘};

int nRcvd=0,nCount=0;

do{

ret = recv(m_socClientTCP_UdpAssociate,resAuth+nRcvd,2-nRcvd,0);

if(ret==SOCKET_ERROR){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

nRcvd += nRet;

}

while((nRcvd!=2)&&(++nCount<1000));

if(nCount>=1000){return NC_E_PROXY_RECEIVE}

if (resAuth[1]!=0)     return NEM_E_WM_CREATE_PROXYAUTHFAILED;

// 密码验证通过了

}

// 开始发送向目标服务器的连接请求，其中DST.ADDR是目标服务器的地址，DST.PORT是目标服务器的UDP端口

char reqSubNego[10]={(char)0x05,(char)0x03,(char)0x00,(char)0x01,(char)0x00,(char)0x00,(char)0x00,(char)0x00,(char)0x00,(char)0x00};

*(unsigned long*)&reqSubNego[4] =saiServerUDP.sin_addr.S_un.S_addr; // cmd: DEST.addr

*(unsigned short*)&reqSubNego[8]=saiServerUDP.sin_port; // cmd: DEST.port in network octet order

nRet=send(m_socClientTCP_UdpAssociate,(const char*)reqSubNego,10,0);

if (nRet==SOCKET_ERROR) return NEM_E_WM_CREATE_PROXYREQFAILED;

// 接收响应信息

int nRecvCount = 0;

int nRecvBufferLen = 10;

char szRecvBuf[10];

nRet = 0;

if(FD_ISSET(m_socClientTCP_UdpAssociate,&fdread))

{

int nRcvd=0,nCount=0;

do{

nRet = recv(m_socClientTCP_UdpAssociate,(char*)szRecvBuf+nRcvd,10-nRcvd,0);

if(nRet==SOCKET_ERROR){return NC_E_PROXY_RECEIVE|WSAGetLastError();}

nRcvd += nRet;

}

while((nRcvd!=10)&&(++nCount<1000));

if(nCount>=1000){return NC_E_PROXY_RECEIVE;}

if (szRecvBuf[0]!=0x05||szRecvBuf[1]!=0x00){return NC_E_PROXY_PROTOCOL_VERSION_SUB;}

}

else

{

return NCM_E_WM_CREATE_PROXYREQUESTFAILED;

}

// 代理服务器绑定udp地址BND.ADR，一般代理服务器都是多宿主机器，因此这个绑定地址是局域网地址，代理服务器绑定udp端口BND.PORT

// m_ulProxyUDPAddr 代理绑定地址

// m_usUDPAssociatePort 代理绑定端口

memmove(&m_ulProxyUDPAddr,&szRecvBuf[4],4);

memmove(&m_usUDPAssociatePort,&szRecvBuf[8],2);

m_bUDPAssociated = TRUE;

// 至此，得到了代理绑定的地址和端口，客户端就可以通过它来收发UDP数据报了

// 客户端收发实例

// 首先创建数据报套接字，绑定套接字，得到本地数据报套接字地址，端口

SOCKET m_socClientUDP=WSASocket(AF_INET,SOCK_DGRAM,0,NULL,0,WSA_FLAG_OVERLAPPED);

SOCKADDR_IN saiLocal;

memset(&saiLocal,0,sizeof(saiLocal));

saiLocal.sin_family = AF_INET;

saiLocal.sin_port = 0;

saiLocal.sin_addr.S_un.S_addr = INADDR_ANY;

// 绑定本地udp套接字地址，地址+端口由系统决定

if (bind(m_socClientUDP, (SOCKADDR *)&saiLocal, sizeof(saiLocal)  == SOCKET_ERROR)

getsockname(m_socClientUDP, (sockaddr*)&saiLocal, &len);

// m_ulHostAddr 本机绑定地址

// m_usHostPortUdp 本机绑定端口

m_ulHostAddr = saiLocal.sin_addr.S_un.S_addr;

m_usHostPortUdp = saiLocal.sin_port;

// 按照格式，发送数据

SOCKADDR_IN saiProxy;

memset(&saiProxy,0,sizeof(saiProxy));

saiProxy.sin_family = AF_INET;

saiProxy.sin_addr.S_un.S_addr = m_ulProxyUDPAddr; // 代理绑定的udp地址

saiProxy.sin_port = m_usUDPAssociatePort; // 代理绑定的udp端口

// 每个UDP包必须携带如下所述的头：

      +----+------+------+----------+----------+----------+

      |RSV | FRAG | ATYP | DST.ADDR | DST.PORT |   DATA   |

      +----+------+------+----------+----------+----------+

      | 2  |  1   |  1   | Variable |    2     | Variable |

      +----+------+------+----------+----------+----------+

// 其中 ATYP==0x01 表示采用 IPV4 地址，那么头长度就是10，DST.ADDR并不是服务器地址，而是本机绑定地址，DST.PORT是本机绑定端口

char buf[10+2]={‘0x00‘,‘0x00‘,‘0x00‘,‘0x01‘,‘0xff‘};

memmove(&buf[4],&m_ulHostAddr,4);

*(unsigned short*)&buf[8]=m_usHostPortUDP;

int nRet = sendto(m_socClientUDP,buf,12,0,(SOCKADDR*)&saiProxy,sizeof(saiProxy));

// 接收数据

int nLen = sizeof(saiProxy);

char buf=new char[MAX_UDPLEN];

nRet = recvfrom(m_socClientUDP,buf,MAX_UDPLEN,0,(SOCKADDR *)&saiProxy,&nLen);

if(nRet==SOCKET_ERROR) return SOCKET_ERROR;

BYTE flag=0xff;

if(memcmp(&buf[0],&flag,1)==0) return SOCKET_ERROR;

BYTE byProxyHead[20];

byProxyHead[0]=byProxyHead[1]=byProxyHead[2]=0;

byProxyHead[3]=1;

*(unsigned long*)&byProxyHead[4] = saiServerUDP.sin_addr.S_un.S_addr;

*(unsigned short*)&byProxyHead[8] = saiServerUDP.sin_port;

byProxyHead[10]=byProxyHead[11]=byProxyHead[12]=0;

byProxyHead[13]=1;

*(unsigned long*)&byProxyHead[14] = m_ulHostAddr;

*(unsigned short*)&byProxyHead[18] = m_usHostPortUdp;

int i=0;

BOOL bIsForMe=FALSE;

if(memcmp(&byProxyHead[0],&buf[i],4)==0)

{

unsigned long ulRetAddr = *(unsigned long*)&buf[i+4];

if(ulRetAddr==m_ulHostAddr)

{

unsigned short usRetPort = ntohs((unsigned short)(*(unsigned short*)&buf[i+8]));

if(usRetPort==m_usHostPortUdp)

{

bIsForMe=TRUE;

}

}

i+=10;

}

// 客户端收发结束

// 服务器端发送实例

// m_ulProxyUDPAddr 代理绑定地址

// m_usUDPAssociatePort 代理绑定端口

// m_ulHostAddr 本机绑定地址

// m_usHostPortUdp 本机绑定端口

// 客户端必须把上面的m_ulProxyUDPAddr,m_usUDPAssociatePort,m_ulHostAddr,m_usHostPortUdp告知服务器，服务器通过这两个套接字进行数据的收发

// 服务器创建数据报套接字

SOCKET m_socUDP=WSASocket(AF_INET,SOCK_DGRAM,0,NULL,0,WSA_FLAG_OVERLAPPED);

// 代理的udp中继地址

SOCKADDR_IN saiClient;

saiClient.sin_family = AF_INET;

saiClient.sin_addr.S_un.S_addr = m_ulProxyUDPAddr;

saiClient.sin_port = m_usUDPAssociatePort;

// 如果远程目标在代理服务器后面，透过代理，指定远程目标的socks信息，参照RFC1928

char buffer[10]={‘\\0‘};

buffer[0]=buffer[1]=buffer[2]=0;

buffer[3]=1; // No Fragment, It‘s a dependent udp, no need for socks server to arrange udp fragments

// 目标机器的地址端口，透过代理后发向这里

*(int*)&buffer[4]=m_ulHostAddr;

*(unsigned short*)&buffer[8]=m_usHostPortUdp;

BYTE buf[DATA_BUFSIZE]={‘\\0‘};

memmove(&buf[10],&szSendbuf[0],dwLength);

memmove(&buf[0],&buffer[0],10);

int nSent = sendto(m_socUDP, (const char*)&buf[0], dwLength+10, 0, (SOCKADDR*)&saiClient,sizeof(saiClient));