tmp

与postgresql数据库结合的数据库水印软件包

package Watermill.kernel;

import java.sql.*;

public class Owners extends PersistantMap {
    
    Connection c;
    String ownersTable;

    public Owners(Connection c,String ownersTable){
	// super(c,ownersTable);
	this.c = c;
	this.ownersTable = ownersTable;
    }
    
    public void add(String key,Object o){
	// Nothing for the moment
	// TODO
    }

    public void dropAll() {
	// Nothing for the moment
	// TODO
    }

    public Object get(String key) {
	// Nothing for the moment
	// TODO
	return null;
    }
}
package Watermill.kernel;

import java.io.*;

public class Pair implements Serializable {
    public Identifier first,second;
    public Pair(Identifier first,Identifier second){
	this.first=first;
	this.second=second;
    }
    public String toString(){
	return "Pair ("+first+","+second+")";
    }

    public boolean equals(Object o){
	if (!(o instanceof Pair))
            return false;
        Pair i = (Pair)o;

	return first.equals(i.first) && second.equals(i.second);
    }

    public int hashCode(){
	return first.hashCode();
    }
}

package Watermill.kernel;

import java.io.*;
import java.sql.*;
import java.util.*;

abstract public class PairPersistantMap {

    abstract public Vector getKeys();

    abstract public void add(String key1,String key2,Object o);

    abstract public void dropAll();

    abstract public Object get(String key1,String key2);
}
package Watermill.kernel;

import java.io.*;
import java.util.Vector;

public class Pairs extends Vector implements Serializable {
    
}
package Watermill.kernel;

public class Parameters {
    OwnerData ownerData;
    
    public Parameters(){
	ownerData=new OwnerData("alice","Alice in wonderland","23L4KFSDFJLFKSDFsdEZ234O23K34K32LK42323433");
    }
}
package Watermill.kernel;

import java.io.*;
import java.sql.*;

abstract public class PersistantMap {
    
    
    abstract public void add(String key,Object o);

    abstract public void dropAll();
	
    abstract public Object get(String key);
}
package Watermill.kernel;

import java.io.*;

public class PersonnalData implements Serializable {

    public String id,description,publicKey;
    
    public PersonnalData(String id,String description,String publicKey){
	this.id=id;
	this.description=description;
	this.publicKey=publicKey;
    }

    public String getId(){
	return id;
    }
    
    public String toString(){
	return id+"|"+description+"|"+publicKey;
    }
}
package Watermill.kernel;

import java.io.*;

abstract public class Pool implements Serializable {
    public String poolName;
    public Document document;
    public WSchema wschema;

    public Pool(String ipn,Document id,WSchema iws){
	poolName=ipn;
	document=id;
	wschema=iws;
	Msg.debug("Pool computation not implemented.");
    }
    public String getName(){
	return poolName;
    }

    abstract public Watermark watermark(Document d,int seed);
}
package Watermill.kernel;

import java.sql.*;
import java.io.*;
// import Watermill.relational.*;

public class Pools {
    private PersistantMap container;

    public Pools(PersistantMap container){
	this.container=container;
	Msg.debug("Pools autocreate not implemented.");
    }

    public void add(Pool p){
	container.add(p.getName(),p);
    }

    public Pool getPool(String poolName){
	return (Pool)(container.get(poolName));
    }
    
    public void dropAll(){
	container.dropAll();
    }

    /*
    public static void main(String arg[]){
    Document d=new DB("david","david","");
    Schema s=d.getSchema();
    WSchema ws=new WSchema(s,null,null);
    Pool p=new WIPool("bidule",d,ws);
    
    RMasterDB mdb=new RMasterDB("david","david","");
    Pools ps=new Pools(new RPersistantMap(mdb.connection,"poupoule"));
    ps.add(p);
    Pool newPool=ps.getPool("bidule");
    Msg.println(newPool.getName());
    }
    */
}	
package Watermill.kernel;

import java.io.*;
import java.util.*;

public class ResilientPool extends Pool implements Serializable {
    
    Identifiers identifiers;

    int lsb;
    int N;
    
    public ResilientPool(String ipn,Document id,WSchema iws) {
	super(ipn,id,iws);
	identifiers=id.getModifiableValuesIdentifiers(wschema.getLocalConstraints());
	lsb = 3;
	N = 10;
    }
    
    
    public Watermark watermark(Document doc,int seed) {
	// insert here a way to hash the seed
	Random r = new Random(seed);
	
	Watermark res = new Watermark();
	
	for(Enumeration e=identifiers.elements();e.hasMoreElements();){
	    Identifier id=(Identifier)e.nextElement();
	    // id contains key values and allowed distortions
	    r.setSeed(id.hashCode());
	    int p = r.nextInt(N);
	    if (p == 0) {
		int pos =  r.nextInt(lsb);
		int m = r.nextInt(2);
		int oldv = ((Value)(doc.getValue(id))).get();
		int newv;
		int d = 1 << pos;
		if ((oldv & d) > 0) { 
		    if (m == 0)
			res.put(id,new Value(-d));
		}
		else {
		    if (m == 1)
			res.put(id,new Value(d));
		}
	    }
	    
	}
	
	return res;
    }

}
package Watermill.kernel;

public class Schema {
}
package Watermill.kernel;

import java.io.*;

public class SerialPool implements Serializable {
    private String data="empty";

    public SerialPool(String data){
	this.data=data;
    }
    public String getData(){
	return data;
    }
}
package Watermill.kernel;

public class UserData extends PersonnalData {
    public UserData(String id,String desc,String key){
	super(id,desc,key);
    }
}
package Watermill.kernel;

import java.sql.*;
// import Watermill.relational.*;

public class Users {
    private PersistantMap container;
    public Users(PersistantMap container){
	this.container=container;
    }
    public void add(UserData u){
	container.add(u.getId(),u);
    }

    public void dropAll(){
	container.dropAll();
    }

    public UserData getUserData(String name){
	return (UserData)(container.get(name));
    }
    /*
    public static void main(String arg[]){
    RMasterDB mdb=new RMasterDB("david","david","");
    Users users=new Users(new RPersistantMap(mdb.connection,"utilisateurs"));
    users.add(new UserData("bob","bob le routard","12355GTTGT"));
    Msg.println(users.getUserData("bob").toString());
    }
    */
}
package Watermill.kernel;

import java.io.*;

public class Value implements Serializable {
    private int i;

    public Value(int ii){
	set(ii);
    }
    public int get(){
	return i;
    }
    public void set(int ii){
	i=ii;
    }
    public String toString(){
	return "Value "+i;
    }
}
package Watermill.kernel;

import java.util.*;
import java.io.*;

public class Watermark extends HashMap implements Serializable {
    public double correlate(Document original,Document suspect){
	int size=keySet().size();
	int match=0;

	for(Iterator i=keySet().iterator();i.hasNext();){
	    Identifier id=(Identifier)i.next();
	    int originalValue=original.getValue(id).get();
	    Msg.debug("original "+originalValue);
	    
	    Value s=(Value)suspect.getValue(id);
	    if (s!=null){
		int suspectValue=s.get();
		Msg.debug("suspect "+suspectValue);
		int mark=((Value)get(id)).get();
		Msg.debug("mark "+mark);
		if (originalValue+mark==suspectValue)
		    match++;
	    }
	    else {
		Msg.debug("An element is missing");
	    }
	}

	return (double)match/(double)size;
    }
}
package Watermill.kernel;

import java.io.*;
import java.util.*;

public class WIPool extends Pool implements Serializable {
    /** A Precompiled pool for weight independent queries **/

    public Identifiers identifiers;
    public DependencyMatrix depMatrix;
    public HashMap classes=new HashMap();
    public Pairs pairs=new Pairs();

    public WIPool(String ipn,Document id,WSchema iws){
	super(ipn,id,iws);

	identifiers=id.getModifiableValuesIdentifiers(wschema.getLocalConstraints());
	Msg.debug("Identifiers:"+identifiers.toString());
		
	depMatrix=id.getDependency(wschema.getGlobalConstraints());
	Msg.debug("DepMatrix:"+depMatrix.toString());

	reductMatrix(1,2);
	Msg.debug("Warning : constant maxlocal=1 and minglobal=2 in reductmatrix");

	//Msg.debug("Reducted depMatrix:"+depMatrix.toString());
	
	computeMap();
	Msg.debug("Classes:"+classes.toString());
	computePairs();
	Msg.debug("Pairs:"+pairs.toString());
    }

    public void reductMatrix(int maxLocal,int minGlobal){
	if (depMatrix.size()==1) return;

	DependencyMatrix dep=(DependencyMatrix)depMatrix.clone();

	int currentPos=-1;
	int targetPos;

	do {
	    currentPos++;
	    targetPos=currentPos;
	    
	    Identifiers current=(Identifiers)dep.get(currentPos);
	    Identifiers target;
	    do {
		targetPos++;
		Msg.debug("positions:"+currentPos+","+targetPos);
		target=(Identifiers)dep.get(targetPos);
		
		if (delta(current,target)*maxLocal<=minGlobal){
		    Msg.debug("Dependency "+currentPos+":"+current+"  and "+targetPos+":"+target+" are similar");
		    Msg.debug("Removing "+targetPos);
		    dep.remove(targetPos);
		}
	    }while((targetPos+1<dep.size()));
	}while(currentPos+2<dep.size());

	depMatrix=dep;
    }

    public int delta(Identifiers a,Identifiers b){
	int res=0;

	for(Enumeration e=a.elements();e.hasMoreElements();){
	    Identifier i=(Identifier)e.nextElement();
	    if (!(b.contains(i)))
		res++;
	}

	for(Enumeration e=b.elements();e.hasMoreElements();){
	    Identifier i=(Identifier)e.nextElement();
	    if (!(a.contains(i)))
		res++;
	}
	return res;
    }

    public boolean anyInclusion(Set a,Set b){
	return ((a.containsAll(b))||(b.containsAll(a)));
    }

    public void computePairs(){
	Identifiers ids=(Identifiers)identifiers.clone();
	Msg.debug("computePairs : "+ids.toString());

	while(ids.size()>1) {
	    Msg.debug("Current size "+ids.size());
	    int currentPos=0,targetPos=0;
	    Identifier current=(Identifier)ids.get(currentPos);
	    Identifier target;
	    do {
		targetPos++;
		Msg.debug("positions:"+currentPos+","+targetPos);
		target=(Identifier)ids.get(targetPos);
	    }while((targetPos+1<ids.size())&&!(classes.get(current).equals(classes.get(target))));
	    
	    if (targetPos+1<ids.size()){
		pairs.add(new Pair(current,target));
		Msg.debug("adding "+currentPos+","+targetPos);
		Msg.debug("Removing "+targetPos);
		ids.remove(targetPos);
	    }
	    Msg.debug("Removing "+currentPos);
	    ids.remove(currentPos);
	    
	}
    }

    public void computeMap(){
	for(Enumeration e=identifiers.elements();e.hasMoreElements();){
	    Identifier id=(Identifier)e.nextElement();

	    Msg.debug("Looking queries depending on "+id.toString());

	    int i=0;
	    for(Enumeration e2=depMatrix.elements();e2.hasMoreElements();i++){
		Identifiers dep=(Identifiers)e2.nextElement();
		int pos=dep.indexOf(id);
		if(pos==-1)
		    Msg.debug("no match !");
		if (pos!=-1){
		    HashSet s=(HashSet)classes.get(id);
		    if (s==null){
			s=new HashSet();
			s.add(new Integer(i));
			classes.put(id,s);
		    }
		    else {
			s.add(new Integer(i));
			classes.put(id,s);
		    }
		}
	    }
	}
    }


    public Watermark watermark(Document doc,int seed){
	Random r=new Random(seed);
	Watermark res=new Watermark();
	Msg.debug("Watermark");
	Msg.debug("Pairs : "+pairs.toString());

	for(Enumeration e=pairs.elements();e.hasMoreElements();){
	    Pair p=(Pair)e.nextElement();
	    Msg.debug("watermarking in pair "+p.toString());
	    boolean b=r.nextBoolean();
	    int d=p.first.maxDistortion;
	    if (p.second.maxDistortion<d)
		d=p.second.maxDistortion;
	    if (b) 
		d=-d;
	    res.put(p.first,new Value(d));
	    res.put(p.second,new Value(-d));
	    doc.addValue(p.first,new Value(d));
	    doc.addValue(p.second,new Value(-d));

	}
	return res;
    }
}
package Watermill.kernel;

import java.io.*;

public class WSchema implements Serializable {
    public Schema schema;
    public LocalConstraints localConstraints;
    public GlobalConstraints globalConstraints;

    public WSchema(Schema s,LocalConstraints lc,GlobalConstraints gc){
	schema=s;
	localConstraints=lc;
	globalConstraints=gc;
	Msg.debug("Schema control not implemented.");
    }
    public LocalConstraints getLocalConstraints(){
	return localConstraints;
    }
    public GlobalConstraints getGlobalConstraints(){
	return globalConstraints;
    }
}