tmp

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

/*
 * 
 * Copyright 2003,2004 The Watermill Team
 *
 * This file is part of Watermill.
 *
 *    Watermill is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    Watermill is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with Watermill; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
package Watermill.kernel;

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

public class BroadCast {
    private PairPersistantMap container;
    public BroadCast(PairPersistantMap container){
	this.container=container;
    }
    
    public void add(UserData u,Pool p,Watermark w){
	container.add(u.id,p.getName(),w);
    }

    public Watermark getWatermark(UserData u,String poolName){
	return (Watermark)(container.get(u.id,poolName));
    }

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

    public Vector getKeys(){
	return container.getKeys();
    }

}

package Watermill.kernel;
import Watermill.kernel.*;
import java.util.*;
import java.io.*;

public class Constant {
    public static String configurationFileName="watermill.conf";
    public static boolean eraseBenchmarkData=true; // true if install and uninstall affect ForestCover benchmark data
    public static String masterDBname;
    public static String masterDBuser;
    public static String masterDBpassword;
    public static int secretKey;
    public static String poolTableName="pool";
    public static String usersTableName="client";
    public static String broadCastTableName="broadcast";

    public static void load(){
	Msg.println("Loading configuration");
	String configurationFileFullName = System.getProperty("user.home")+"/"+configurationFileName;
	try{
	    Properties p=new Properties();
	    p.load(new FileInputStream(configurationFileFullName));
	    secretKey = Integer.parseInt(p.getProperty("secretKey"));
	    masterDBname=p.getProperty("masterDBname");
	    masterDBuser=p.getProperty("masterDBuser");
	    masterDBpassword=p.getProperty("masterDBpassword");
	    
	    
	    
	}catch (FileNotFoundException e){
	    Msg.println("Please fill in the watermill.conf file in your home directory with the master database name(which holds any watermarking information), master user name and password.");
	try {
	PrintWriter f = new PrintWriter(new BufferedWriter(new FileWriter(configurationFileFullName)));
	f.println("secretkey=<any character list, secret key for the data owner>"); 
	f.println("masterDBname=< master database user name(which holds any watermarking info.>");
	f.println("masterDBuser=<master database user>");
	f.println("masterDBpassword=<master database password>");
	f.close();
	System.exit(-1);}
	catch (Exception e2){
	Msg.fatal(e2);
	}
	}
	catch (Exception e){
	    Msg.fatal(e);
	}
    }
    static {
	load();
    }
}


	
	
	
	
	
	
	
	
	
	 
	



package Watermill.kernel;

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

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

import java.io.*;

public abstract class Document implements Serializable {
    abstract public Value getValue(Identifier id);
    abstract public void setValue(Identifier id,Value v);
    abstract public void addValue(Identifier id,Value v);
    abstract public Schema getSchema();
    abstract public Identifiers getModifiableValuesIdentifiers(LocalConstraints lc);
    abstract public DependencyMatrix getDependency(GlobalConstraints gc);
    abstract public boolean checkLocalConstraint(Document d,LocalConstraint lc);
    abstract public boolean checkLocalConstraints(Document d,LocalConstraints lc);
    abstract public boolean checkGlobalConstraint(Document d,GlobalConstraint gc);
    abstract public boolean checkGlobalConstraints(Document d,GlobalConstraints gcs);
}
package Watermill.kernel;

public class Doublet {
    public String first,second;

    public Doublet(String first,String second){
	this.first=first;
	this.second=second;
    }
}

package Watermill.kernel;

import java.util.*;

public class Essai {
    /*
    public static void main(String arg[]){
    Vector v=new Vector();
    
    Key k=new Key("toto","tutu");
    KeyValue kv=new KeyValue(k,"titi");
    Identifier i=new Identifier(kv,"tata");
    
    Key k2=new Key("toto","tutu");
    KeyValue kv2=new KeyValue(k2,"titi");
    Identifier i2=new Identifier(kv2,"tatd");
    
    System.out.println("resultat "+i.toString()+"/"+i2.toString()+" : "+i.equals(i2));

    v.add(i);
    System.out.println(i.hashCode());
    System.out.println(i2.hashCode());
    System.out.println(v.indexOf(i2));
    }
    */
}
package Watermill.kernel;

import java.io.*;

public class GlobalConstraint implements Serializable {

    public String tableName;
    public String attributeName;
    public String keyName;
    public int distortion;
    public String condition;

    public GlobalConstraint(GlobalConstraint gc){
	this.tableName=gc.tableName;
	this.attributeName=gc.attributeName;
	this.keyName=gc.keyName;
	this.distortion=gc.distortion;
	this.condition=gc.condition;
    }

    public GlobalConstraint(int distortion,String keyName,String attributeName,String tableName,String condition){
	this.distortion=distortion;
	this.keyName=keyName;
	this.attributeName=attributeName;
	this.tableName=tableName;
	this.condition=condition;
    }
    
    public String toString(){
	return "global constraint "+distortion+"% on query (select "+keyName+","+attributeName+" from "+tableName+" where "+condition+")";
    }
}
package Watermill.kernel;

import java.util.Vector;

public class GlobalConstraints extends Vector {}
package Watermill.kernel;

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

public class GreedyPool extends Pool implements Serializable {
    Identifiers identifiers;
    
    public GreedyPool(String ipn,Document id,WSchema iws){
	super(ipn,id,iws);
	
	identifiers=id.getModifiableValuesIdentifiers(wschema.getLocalConstraints());
	Msg.debug("Identifiers:"+identifiers.toString());
	
    } 

    public Watermark watermark(Document doc,int seed){
	Random r=new Random(seed);
	Watermark res=new Watermark();
	Msg.debug("Watermark");
	
	for(Enumeration e=identifiers.elements();e.hasMoreElements();){
	    Identifier id=(Identifier)e.nextElement();
	    Msg.debug("identifier="+id);
	    boolean b=r.nextBoolean();
	    int d=id.maxDistortion;
	    if (b) d=-d;
	    
	    doc.addValue(id,new Value(d));
	    Msg.debug("Trying distortion "+d+" on identifier "+id.toString());
	    
	    if (doc.checkGlobalConstraints(document,wschema.globalConstraints)){
		Msg.debug("Global distortion ok, keeping.");
		res.put(id,new Value(d));
	    }
	    else {
		Msg.debug("Bad global distortion, reverting.");
		doc.addValue(id,new Value(-d));
	    }
	}
	return res;
    }
}
    
package Watermill.kernel;

import java.io.*;

public class GroupGlobalConstraint implements Serializable {

    public GlobalConstraint gc;
    public String generator;

    public GroupGlobalConstraint(GlobalConstraint gc,String generator){
	this.gc=gc;
	this.generator=generator;
    }
    
    public String toString(){
	return "[group global constraint "+gc+" with generator "+generator+"]";
    }
}
package Watermill.kernel;

import java.util.Vector;

public class GroupGlobalConstraints extends Vector {}
package Watermill.kernel;

import java.io.*;

public class IdentifierInfo implements Serializable {
    public Identifier identifier;
    public int maxDistortion;
}
package Watermill.kernel;

import java.io.*;

public abstract class Identifier implements Serializable {
    public int maxDistortion=666;

    public Identifier(){
	Msg.debug("WARNING : Identifier constructor called !");
    }

    abstract public String toString();

    abstract public boolean equals(Object o);

    abstract public int hashCode();


}
package Watermill.kernel;

import java.util.Vector;

public class Identifiers extends Vector {}
package Watermill.kernel;

import java.io.*;
import java.util.*;
import com.cflex.util.lpSolve.*;

public class ILPool extends Pool implements Serializable{

public static Identifiers identifiers;
public static DependencyMatrix depMatrix;
public static LpModel lpIn;
public static int lc,seed,gd;
public static Document doc;
public static String request;

public ILPool(String ipn,Document id,WSchema iws)throws Exception{
	super(ipn,id,iws);
	doc = id;
	
	
	identifiers=id.getModifiableValuesIdentifiers(wschema.getLocalConstraints());
	Msg.debug("Identifiers:"+identifiers.toString());

	depMatrix=id.getDependency(wschema.getGlobalConstraints());
	Msg.debug("DepMatrix:"+depMatrix.toString());
	
	reductMatrix();
	lpIn = lpModele();
	lpIn.printLp();
	
}

public static void reductMatrix ()throws Exception{
    // choose a random subset of identifiers such that their values is larger than local distortion
    Random r=new Random(seed);
    DependencyMatrix dep=(DependencyMatrix)depMatrix.clone();
    
    for (int j=0;j<dep.size();j++){
	Identifiers id = (Identifiers)dep.get(j);
	for (int i=0; i<id.size(); i++){
	    boolean b=r.nextBoolean();
	    // XIdentifier ident = (XIdentifier)id.get(i) ;
	    Identifier ident = (Identifier)id.get(i);
	    ident.maxDistortion=lc;
	    Value value = doc.getValue(ident);
	    int x = value.get();
	    if (!b | x <=lc) {
		id.remove(ident);
	    }
	}
    }
    depMatrix=dep;
}

public static LpModel lpModele ()throws Exception{
	double globale = 0.0;
	int Ldistinf = 0;
	int indice = 0;
	int Ldistsup =0;int num = 0;
	try{
	    //reductMatrix();
	for (int j=0;j<depMatrix.size();j++){
	Identifiers id = (Identifiers)depMatrix.get(j);
	lpIn = new LpModel(0, id.size());
	lpIn.debug = LpModel.FALSE;
	lpIn.verbose = LpModel.FALSE;
	lpIn.trace = LpModel.FALSE;
	double v1[] = new double[id.size()+1]; // objective function
	double v2[] = new double[id.size()+1]; // model of the global constraint
	 for (int i=0; i<id.size(); i++){
	     double v[] = new double[id.size()+1]; // model of the local constraint
	     Ldistsup = 2*lc ;
	     double rhs;
	     indice = i+1;
	     v2[i+1] = 1 ;
	     v1[i+1] = -1;
	     lpIn.setObjFn(v1);
	     lpIn.setMaximum();
	     num++;
	     v[i+1]=0;
	     v[indice] = 1;
	     rhs = Ldistinf;
	     lpIn.addConstraint(v, LpModel.GE, rhs);
	     rhs = Ldistsup;
	     lpIn.addConstraint(v, LpModel.LE, rhs);
	     lpIn.setInt(indice, LpModel.TRUE);
	 }
	globale = num*lc;
	lpIn.addConstraint(v2, LpModel.GE, globale);
	lpIn.addConstraint(v2, LpModel.LE, globale);
	
	}}
	catch (Exception ex){ ex.printStackTrace(); }
	return lpIn;
   }
    

    public Watermark watermark(Document doc,int is) {
	Watermark res=new Watermark();
	seed = is;
	try {
	    lpIn = lpModele(); // this command generates an exception
	    Msg.debug("Watermark");
	    for (int i=0;i<depMatrix.size();i++){
		Identifiers ids=(Identifiers)depMatrix.get(i);
		Msg.debug("identifiers : "+ids.toString());
		LpSolver lpsolve = new LpSolver(lpIn);
		int q = lpsolve.solve();
		int[]result = new int[ids.size()];
		for(int j=0; j<ids.size();j++){
		    result[j] = (int)lpIn.getResult(j+1)-lc ;
		}
		for(int j=0;j<ids.size();j++){
		    Identifier id=(Identifier)ids.get(j);
		    Msg.debug("watermarking in identifier "+id.toString());
		    int value = result[j];
		    if(value!= 0){
			Value v1 = new Value(value);
			doc.addValue(id,v1);
			res.put(id,new Value(value));}
		}
	    }
	}
	catch (Exception e) {
	    Msg.debug("An exception has occured with resolving linear constraints");
	}
	return res;
    }
}
package Watermill.kernel;

import java.io.*;

public class LocalConstraint implements Serializable {

    public String tableName;
    public String attributeName;
    public int distortion;
    public String keyName;

    public LocalConstraint(int distortion,String tableName,String keyName,String attributeName){
	this.tableName=tableName;
	this.attributeName=attributeName;
	this.distortion=distortion;
	this.keyName=keyName;
    }
    
    public String toString(){
	return "local constraint "+distortion+"% on ("+tableName+","+attributeName+")";
    }
}
package Watermill.kernel;

import java.util.Vector;

public class LocalConstraints extends Vector {}
package Watermill.kernel;

abstract public class Manager {
/** 
    Handling of Pools, Users, BroadCast infos, and basic overall documents operations.
 **/

    public Pools pools;
    public Users users;
    public BroadCast broadcast;
    
    abstract public Document getDocument(String dbname,String dbuser,String dbPassword);
    abstract public Document duplicate(Document source,String targetDbName,UserData u);
}
package Watermill.kernel;

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

public abstract class MasterDB {



}
	
package Watermill.kernel;

public class Msg {
    private static boolean debug=false;

    public static void setDebug(boolean idebug){
	debug=idebug;
    }


    public static void debug(String s){
	if (debug)
	    System.out.println("DEBUG: "+s);
    }

    public static void debug(Throwable e){
	if (debug)
	    e.printStackTrace();
    }


    public static void println(String s){
	System.out.println("Watermill: "+s);
    }

    public static void fatal(String s){
	System.out.println("FATAL: "+s);
	System.exit(-1);
    }

    public static void fatal(Throwable e){
	e.printStackTrace();
	System.exit(-1);
    }
}
package Watermill.kernel;

public class OwnerData extends PersonnalData {

    public OwnerData(String id,String description,String publicKey) {
	super(id,description,publicKey);
    }

}